直接创建WEB项目即可;

  public class Startup
{
//startup.cs是站点启动时具体做了哪些事情,主要是开启了一个mvc服务。
public Startup(IConfiguration configuration)
{
Configuration = configuration;
} public IConfiguration Configuration { get; } // This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.Configure<CookiePolicyOptions>(options =>
{
// This lambda determines whether user consent for non-essential cookies is needed for a given request.
options.CheckConsentNeeded = context => true;
options.MinimumSameSitePolicy = SameSiteMode.None;
}); services.AddSession(); services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
} // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
else
{
app.UseExceptionHandler("/Error");
app.UseHsts();
} app.UseHttpsRedirection();
app.UseStaticFiles(); //如果不添加将导致样式文件不能被客户端加载
app.UseCookiePolicy();
app.UseSession(); app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
}
);
}
}

创建一个DB类用于查数据:

 public class DB : DbContext
{
public DB()
{ //如果没有数据库,自动创建,有了什么都不干
Database.EnsureCreated();
}
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{ //对于这个上下文重写此方法以配置要使用的数据库(和其他选项)。对于上下文的每个实例调用此方法创建。 //加载appsetting.json
IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json").Build(); string connectionString = configuration["DBSetting:ConnectString"];
optionsBuilder.UseSqlServer(connectionString); base.OnConfiguring(optionsBuilder);
} public DbSet<studen> studen { set; get; } public DbSet<xx> xx { set; get; } }
//原文:https://blog.csdn.net/weixin_41609327/article/details/80821798

appsettings.json

{
"Logging": {
"LogLevel": {
"Default": "Warning"
}
},
"DBSetting": {
"ConnectString": "server=.;database=test_core;uid=sa;pwd=123" },
"AllowedHosts": "*"
}

有DB类肯定少不了help类

  /// 此类为抽象类,
/// 不允许实例化,在应用时直接调用即可
/// </summary>
// abstract 抽象类标识
public abstract class SqlHelper
{
//加载appsetting.json
static IConfiguration configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json").Build(); /// <summary>
/// 数据库连接字符串
/// </summary>
private static readonly string connectionString = configuration["DBSetting:ConnectString"]; //获取DBSetting下的ConnectString值
private static Hashtable parmCache = Hashtable.Synchronized(new Hashtable()); #region//ExecteNonQuery方法 /// <summary>
///执行一个不需要返回值的SqlCommand命令,通过指定专用的连接字符串。
/// 使用参数数组形式提供参数列表
/// </summary>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecteNonQuery(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
// =执行SQL语句
SqlCommand cmd = new SqlCommand();
using (SqlConnection conn = new SqlConnection(connectionString))
{
//通过PrePareCommand方法将参数逐个加入到SqlCommand的参数集合中
PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
int val = cmd.ExecuteNonQuery();
//清空SqlCommand中的参数列表
cmd.Parameters.Clear();
return val;
}
} /// <summary>
///执行一个不需要返回值的SqlCommand命令,通过指定专用的连接字符串。
/// 使用参数数组形式提供参数列表
/// </summary>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecteNonQuery(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
return ExecteNonQuery(connectionString, cmdType, cmdText, commandParameters);
} /// <summary>
///存储过程专用
/// </summary>
/// <param name="cmdText">存储过程的名字</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecteNonQueryProducts(string cmdText, params SqlParameter[] commandParameters)
{
return ExecteNonQuery(CommandType.StoredProcedure, cmdText, commandParameters);
} /// <summary>
///Sql语句专用
/// </summary>
/// <param name="cmdText">T_Sql语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个数值表示此SqlCommand命令执行后影响的行数</returns>
public static int ExecteNonQueryText(string cmdText, params SqlParameter[] commandParameters)
{
return ExecteNonQuery(CommandType.Text, cmdText, commandParameters);
} #endregion
#region//GetTable方法 /// <summary>
/// 执行一条返回结果集的SqlCommand,通过一个已经存在的数据库连接
/// 使用参数数组提供参数
/// </summary>
/// <param name="connecttionString">一个现有的数据库连接</param>
/// <param name="cmdTye">SqlCommand命令类型</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
public static DataTableCollection GetTable(string connecttionString, CommandType cmdTye, string cmdText, SqlParameter[] commandParameters)
{
SqlCommand cmd = new SqlCommand();
DataSet ds = new DataSet();
using (SqlConnection conn = new SqlConnection(connecttionString))
{
PrepareCommand(cmd, conn, null, cmdTye, cmdText, commandParameters);
SqlDataAdapter adapter = new SqlDataAdapter();
adapter.SelectCommand = cmd;
adapter.Fill(ds);
}
DataTableCollection table = ds.Tables;
return table;
} /// <summary>
/// 执行一条返回结果集的SqlCommand,通过一个已经存在的数据库连接
/// 使用参数数组提供参数
/// </summary>
/// <param name="cmdTye">SqlCommand命令类型</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
public static DataTableCollection GetTable(CommandType cmdTye, string cmdText, SqlParameter[] commandParameters)
{
return GetTable(connectionString, cmdTye, cmdText, commandParameters);
} /// <summary>
/// 执行存储过程专用
/// </summary>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
public static DataTableCollection GetTableProducts(string cmdText, SqlParameter[] commandParameters)
{
return GetTable(CommandType.StoredProcedure, cmdText, commandParameters);
} /// <summary>
/// 执行Sql语句专用
/// </summary>
/// <param name="cmdText"> T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个表集合(DataTableCollection)表示查询得到的数据集</returns>
public static DataTableCollection GetTableText(string cmdText, SqlParameter[] commandParameters)
{
return GetTable(CommandType.Text, cmdText, commandParameters);
}
#endregion /// <summary>
/// 为执行命令准备参数
/// </summary>
/// <param name="cmd">SqlCommand 命令</param>
/// <param name="conn">已经存在的数据库连接</param>
/// <param name="trans">数据库事物处理</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">Command text,T-SQL语句 例如 Select * from Products</param>
/// <param name="cmdParms">返回带参数的命令</param>
private static void PrepareCommand(SqlCommand cmd, SqlConnection conn, SqlTransaction trans, CommandType cmdType, string cmdText, SqlParameter[] cmdParms)
{
//判断数据库连接状态
if (conn.State != ConnectionState.Open)
conn.Open();
cmd.Connection = conn;
cmd.CommandText = cmdText;
//判断是否需要事物处理
if (trans != null)
cmd.Transaction = trans;
cmd.CommandType = cmdType;
if (cmdParms != null)
{
foreach (SqlParameter parm in cmdParms)
cmd.Parameters.Add(parm);
}
} /// <summary>
/// Execute a SqlCommand that returns a resultset against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>A SqlDataReader containing the results</returns>
public static SqlDataReader ExecuteReader(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
SqlCommand cmd = new SqlCommand();
SqlConnection conn = new SqlConnection(connectionString);
// we use a try/catch here because if the method throws an exception we want to
// close the connection throw code, because no datareader will exist, hence the
// commandBehaviour.CloseConnection will not work
try
{
PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
SqlDataReader rdr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
cmd.Parameters.Clear();
return rdr;
}
catch
{
conn.Close();
throw;
}
}
#region//ExecuteDataSet方法 /// <summary>
/// return a dataset
/// </summary>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>return a dataset</returns>
public static DataSet ExecuteDataSet(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
SqlConnection conn = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
SqlDataAdapter da = new SqlDataAdapter();
DataSet ds = new DataSet();
da.SelectCommand = cmd;
da.Fill(ds);
return ds;
}
catch
{
conn.Close();
throw;
}
} /// <summary>
/// 返回一个DataSet
/// </summary>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>return a dataset</returns>
public static DataSet ExecuteDataSet(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
return ExecuteDataSet(connectionString, cmdType, cmdText, commandParameters);
} /// <summary>
/// 返回一个DataSet
/// </summary>
/// <param name="cmdText">存储过程的名字</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>return a dataset</returns>
public static DataSet ExecuteDataSetProducts(string cmdText, params SqlParameter[] commandParameters)
{
return ExecuteDataSet(connectionString, CommandType.StoredProcedure, cmdText, commandParameters);
} /// <summary>
/// 返回一个DataSet
/// </summary> /// <param name="cmdText">T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>return a dataset</returns>
public static DataSet ExecuteDataSetText(string cmdText, params SqlParameter[] commandParameters)
{
return ExecuteDataSet(connectionString, CommandType.Text, cmdText, commandParameters);
} public static DataView ExecuteDataSet(string connectionString, string sortExpression, string direction, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
SqlConnection conn = new SqlConnection(connectionString);
SqlCommand cmd = new SqlCommand();
try
{
PrepareCommand(cmd, conn, null, cmdType, cmdText, commandParameters);
SqlDataAdapter da = new SqlDataAdapter();
DataSet ds = new DataSet();
da.SelectCommand = cmd;
da.Fill(ds);
DataView dv = ds.Tables[].DefaultView;
dv.Sort = sortExpression + " " + direction;
return dv;
}
catch
{
conn.Close();
throw;
}
}
#endregion #region // ExecuteScalar方法 /// <summary>
/// 返回第一行的第一列
/// </summary>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个对象</returns>
public static object ExecuteScalar(CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
return ExecuteScalar(SqlHelper.connectionString, cmdType, cmdText, commandParameters);
} /// <summary>
/// 返回第一行的第一列存储过程专用
/// </summary>
/// <param name="cmdText">存储过程的名字</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个对象</returns>
public static object ExecuteScalarProducts(string cmdText, params SqlParameter[] commandParameters)
{
return ExecuteScalar(SqlHelper.connectionString, CommandType.StoredProcedure, cmdText, commandParameters);
} /// <summary>
/// 返回第一行的第一列Sql语句专用
/// </summary>
/// <param name="cmdText">者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>返回一个对象</returns>
public static object ExecuteScalarText(string cmdText, params SqlParameter[] commandParameters)
{
return ExecuteScalar(SqlHelper.connectionString, CommandType.Text, cmdText, commandParameters);
} /// <summary>
/// Execute a SqlCommand that returns the first column of the first record against the database specified in the connection string
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
public static object ExecuteScalar(string connectionString, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
SqlCommand cmd = new SqlCommand(); using (SqlConnection connection = new SqlConnection(connectionString))
{
PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
object val = cmd.ExecuteScalar();
cmd.Parameters.Clear();
return val;
}
} /// <summary>
/// Execute a SqlCommand that returns the first column of the first record against an existing database connection
/// using the provided parameters.
/// </summary>
/// <remarks>
/// e.g.:
/// Object obj = ExecuteScalar(connString, CommandType.StoredProcedure, "PublishOrders", new SqlParameter("@prodid", 24));
/// </remarks>
/// <param name="connectionString">一个有效的数据库连接字符串</param>
/// <param name="cmdType">SqlCommand命令类型 (存储过程, T-SQL语句, 等等。)</param>
/// <param name="cmdText">存储过程的名字或者 T-SQL 语句</param>
/// <param name="commandParameters">以数组形式提供SqlCommand命令中用到的参数列表</param>
/// <returns>An object that should be converted to the expected type using Convert.To{Type}</returns>
public static object ExecuteScalar(SqlConnection connection, CommandType cmdType, string cmdText, params SqlParameter[] commandParameters)
{
SqlCommand cmd = new SqlCommand();
PrepareCommand(cmd, connection, null, cmdType, cmdText, commandParameters);
object val = cmd.ExecuteScalar();
cmd.Parameters.Clear();
return val;
} #endregion /// <summary>
/// add parameter array to the cache
/// </summary>
/// <param name="cacheKey">Key to the parameter cache</param>
/// <param name="cmdParms">an array of SqlParamters to be cached</param>
public static void CacheParameters(string cacheKey, params SqlParameter[] commandParameters)
{
parmCache[cacheKey] = commandParameters;
} /// <summary>
/// Retrieve cached parameters
/// </summary>
/// <param name="cacheKey">key used to lookup parameters</param>
/// <returns>Cached SqlParamters array</returns>
public static SqlParameter[] GetCachedParameters(string cacheKey)
{
SqlParameter[] cachedParms = (SqlParameter[])parmCache[cacheKey];
if (cachedParms == null)
return null;
SqlParameter[] clonedParms = new SqlParameter[cachedParms.Length];
for (int i = , j = cachedParms.Length; i < j; i++)
clonedParms[i] = (SqlParameter)((ICloneable)cachedParms[i]).Clone();
return clonedParms;
}
/// <summary>
/// 检查是否存在
/// </summary>
/// <param name="strSql">Sql语句</param>
/// <returns>bool结果</returns>
public static bool Exists(string strSql)
{
int cmdresult = Convert.ToInt32(ExecuteScalar(connectionString, CommandType.Text, strSql, null));
if (cmdresult == )
{
return false;
}
else
{
return true;
}
} /// <summary>
/// 检查是否存在
/// </summary>
/// <param name="strSql">Sql语句</param>
/// <param name="cmdParms">参数</param>
/// <returns>bool结果</returns>
public static bool Exists(string strSql, params SqlParameter[] cmdParms)
{
int cmdresult = Convert.ToInt32(ExecuteScalar(connectionString, CommandType.Text, strSql, cmdParms));
if (cmdresult == )
{
return false;
}
else
{
return true;
}
} //原文:https://blog.csdn.net/weixin_41609327/article/details/80786764
}

SqlHelp

public DataTable GetStuden()
{
string sql = "select * from studen;";
var data = SqlHelper.GetTable(CommandType.Text,sql,new SqlParameter[] { });
return data[];
}

DAL

一个保存类:

public static class save
{ public static void JsonWrite(string configpath,string str,out string name,out string filename)
{
//string configpath = System.AppDomain.CurrentDomain.BaseDirectory + "/json/"; configpath = configpath + "/json/"; if (!Directory.Exists(configpath))//如果目录不存在就创建
{
Directory.CreateDirectory(configpath);
}
filename = configpath + "/"; name = "Json_" + DateTime.Now.ToString("yyyy_MM_dd_HH_mm_ss_ffff") + ".json";//用日期对文件命名; filename = filename + name; // 一个 文件的 绝对路径 out 出去 给使用
//创建或打开文件, AppendText 向文件末尾追加记录
StreamWriter mySw = File.AppendText(filename); // 查找是否有该路径的文件 并打开
string a = str;
mySw.WriteLine(a); // 写入某数据 //关闭文件
mySw.Close(); // 关闭写入流
}
}

保存文件类

到控制器下载了。

 public IActionResult Json()
{
using (var db = new DB())
{
List<studen> list = db.studen.GroupBy(b=>new { b.Id,b.Name }).Select(b => new studen
{
Id = b.Key.Id,
Name = b.Key.Name
}).ToList();
db.studen.ToList(); var xx = db.xx.GroupBy(x => new { x.id }).Select(v => new xx
{
id=v.Key.id,
name= v.Sum(x => x.name)
}).ToList();
string json = "[";
foreach (var item in list)
{
json += "{\"id\":\""+item.Id+"\",\"name\":\""+item.Name+"\" },";
}
json = json.Substring(, json.Length - ); //删除最后一个逗号,
json += "]";
//string root = Directory.GetParent(AppContext.BaseDirectory).Parent.Parent.Parent.FullName; //Parent退到上个目录
string contentRootPath = _hostingEnvironment.ContentRootPath; // .net core获取基目录的用法
string name; // out 出来的是路径加上json文件名
string file; // 绝对路径
save.JsonWrite(contentRootPath, json.ToString(),out name, out file); //写入文件 并保存 HttpContext.Session.SetString("file",file); // core 的 Session 就得这么用 还得using Microsoft.AspNetCore.Http; // 读取某json文件
string str = ""; using (FileStream fs = new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) // 获取文件流
{
using (StreamReader sr = new StreamReader(fs, Encoding.GetEncoding("utf-8"))) // 读取文件流
{
str = sr.ReadToEnd().ToString(); // 获取 文件的 全部 转 字符串
sr.Close();
}
fs.Close();
} }
// new filestram 须文件的绝对路径 获取文件流 输入出的文件格式 输出的文件名称
return File(new FileStream(HttpContext.Session.GetString("file"), FileMode.Open), "application/octet-stream", $"导出测试{DateTime.Now.ToString("yyyy年MM月dd日HH点mm分ss秒")}.json"); if (System.IO.File.Exists("文件的绝对路径"))
{ //删除文件
System.IO.File.Delete("文件的绝对路径");
}
} //public IActionResult download()
//{
// return File(new FileStream(HttpContext.Session.GetString("file"), FileMode.Open), "application/octet-stream", $"导出测试{DateTime.Now.ToString("yyyyMMddHHmmss")}.json");
//}

.NET Core随笔把数据库数据查出来转JSON并输出的更多相关文章

  1. 使用 Solr 创建 Core 并导入数据库数据

    1. 输入 http://localhost:8080/solr/index.html 来到 Solr 的管理界面: 2. 点击左侧 Core Admin --> Add Core,然后输入自己 ...

  2. EasyUI_tree根据数据库数据生成树形结构JSON格式

    @Entitypublic class PubComp { @Id private String aguid; // 菜单ID private String pguid; // 父菜单 private ...

  3. hive 将hive表数据查询出来转为json对象和json数组输出

    一.将hive表数据查询出来转为json对象输出 1.将查询出来的数据转为一行一行,并指定分割符的数据 2.使用UDF函数,将每一行数据作为string传入UDF函数中转换为json再返回 1.准备数 ...

  4. 第二百七十七节,MySQL数据库-数据表、以及列的增删改查

    MySQL数据库-数据表.以及列的增删改查 1.创建一个表 CREATE(创建) TABLE(表) ENGINE(引擎) ENGINE=INNODB(引擎)还有很多类引擎,这里只是简单的提一下INNO ...

  5. 效率最高的Excel数据导入---(c#调用SSIS Package将数据库数据导入到Excel文件中【附源代码下载】) 转

    效率最高的Excel数据导入---(c#调用SSIS Package将数据库数据导入到Excel文件中[附源代码下载])    本文目录: (一)背景 (二)数据库数据导入到Excel的方法比较   ...

  6. solr 7+tomcat 8 + mysql实现solr 7基本使用(安装、集成中文分词器、定时同步数据库数据以及项目集成)

    基本说明 Solr是一个开源项目,基于Lucene的搜索服务器,一般用于高级的搜索功能: solr还支持各种插件(如中文分词器等),便于做多样化功能的集成: 提供页面操作,查看日志和配置信息,功能全面 ...

  7. ASP.NET Core使用EF Core操作MySql数据库

    ASP.NET Core操作MySql数据库, 这样整套环境都可以布署在Linux上 使用微软的 Microsoft.EntityFrameworkCore(2.1.4) 和MySql出的 MySql ...

  8. 在Linux环境下,将Solr部署到tomcat7中,导入Mysql数据库数据, 定时更新索引

    什么是solr solr是基于Lucene的全文搜索服务器,对Lucene进行了扩展优化. 准备工作 首先,去下载以下软件包: JDK8:jdk-8u60-linux-x64.tar.gz TOMCA ...

  9. jmeter 性能测试 JDBC Request (查询数据库获取数据库数据) 的使用

    JDBC Request 这个Sampler可以向数据库发送一个jdbc请求(sql语句),并获取返回的数据库数据进行操作.它经常需要和JDBC Connection Configuration配置原 ...

随机推荐

  1. 拦截RestTemplate的请求

    RestTemplate一般用于方法内部请求调用,请求报错时难以调试,所以可以为RestTemplate加拦截器进行调试,具体操作如下: 拦截器LoggingClientHttpRequestInte ...

  2. Tomcat 9 管理界面配置

    Tomcat9 在conf/tomcat_user.xml配置后,还是出现如下错误 然后修改tomcat9/webapps/manager/META-INF的context.xml文件

  3. shell整数与小数比较,小数之间比较的方法【转】

    在shell脚本中,无法对浮点数进行比较,如: max=0.1 min=0.01 if [ "$max" -gt "$min" ] then echo &quo ...

  4. [linux]测硬盘读写速度、内存读写速度

    测硬盘的读写速度可以用以下命令:dd if=/dev/zero of=file bs=1M count=1024 测内存读写速度可以使用以下命令: dd if=/dev/zero of=/dev/nu ...

  5. PostgreSQL DISTINCT 和 DISTINCT ON

    select语句中,使用distinct关键字,在处理select list后,结果表可以选择消除重复的行.在SELECT之后直接写入DISTINCT关键字以指定此关键字: SELECT DISTIN ...

  6. windows mysql 修改配置datadir后 重启报错1067

    修改datadir目录 #datadir=C:/ProgramData/MySQL/MySQL Server 5.6/Data datadir=F:/ProgramData/MySQL/MySQL S ...

  7. 微信支付:URL未注册问题

    起因:一个项目已经做好了,微信支付也调通的,域名 www.xxxx.com ,某天客户需要换域名,改为weixin.xxxx.com, 原先的www转向客户自己的官网,结果换了之后,发现微信支付出错: ...

  8. 文档工具的王者Sphinx

    Sphinx https://www.sphinx.org.cn/ Sphinx是一个工具,可以轻松创建由Georg Brandl编写并根据BSD许可证授权的智能和美观文档 它最初是为Python文档 ...

  9. pauseable 库

    pauseable.js https://www.npmjs.com/package/pauseable Pauseable allows you to pause event emitters, t ...

  10. 人脸识别(基于ArcFace)

    我们先来看看效果 上面是根据图片检测出其中的人脸.每个人脸的年龄还有性别,非常强大 第一步: 登录https://ai.arcsoft.com.cn/,注册开发者账号,身份认证,注册应用,得到APPI ...