开发人员正从 Java 8 向 Java 11 转移

此前的 Java 社区报告曾指出，Java 8 仍是开发人员使用的主要版本，新版本并未“得宠”。但 Snyk 近期发布的  JVM Ecosystem Report 2021 则指出，开发人员已经逐渐从 Java 8 迁移到了 Java 11。 JVM Ecosystem Report 2021 展示了关于 JVM 生态系统状态的最大年度调查的结果。该调查在 2021 年 2 月和 3 月的六周时间里进行，收集了来自 2000 多名 Java 开发者的回复。 调查结果显示，有 44.1% 的受访者在生产中使用免费的 AdoptOpenJDK 发行版。但 Oracle 仍然是市场上的重要参与者，其 OpenJDK 构建占 28%，商业 Oracle JDK 占 23%。 40% 的调查参与者在生产中使用了一个以上的 Java 版本。升级到 8 版本以上的人也比预料的要多。目前，有 61.5% 的人在生产中使用 Java 11，近 12% 的人使用最新版本，即调查期间的 Java 15。 Snyk 方面在报告中指出，这表明开发人员确实将他们的 Java 版本升级到了 Java 8 以上的版 […]

在WebApi 中使用AutoFac

参考文档 https://www.cnblogs.com/htsboke/p/10956807.html https://www.cnblogs.com/lenmom/p/8510572.html https://www.cnblogs.com/yaopengfei/p/9479268.html   在WebApi项目中使用AutoFac，结构如下： 首先在Api项目当中引用AutoFac包，如下图所示：   仓储类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1     public interface IUsersRepository
2     {
3         int GetUserIsExists(UsersEntity criteria);
4
5     }
6
7
8     public class UsersRepository : IUsersRepository
9     {
10         Logger log = LogManager.GetLogger("UsersRepository");
11
12         /// <summary>
13         /// 获取用户是否存在
14         /// </summary>
15         /// <param name="criteria"></param>
16         /// <returns></returns>
17         public int GetUserIsExists(UsersEntity criteria)
18         {
19             string sql = "。。。。";
20             try
21             {
22                  //查询sql代码，此处省略。。。。            
               }
28             catch (Exception ex)
29             {
30                 log.Fatal(ex, "获取用户是否存在异常：{0}，SQL：{1}", ex.Message, sql);
31                 return 0;
32             }
33         }
34     }

服务类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
1     //接口  
       public interface IUsersService
4     {
5         int GetUserIsExists(UsersEntity criteria);
6
7     }
8
10     //实现类
11     public class UsersService : IUsersService
12     {
13         private readonly IUsersRepository _usersrepository;    
14         public UsersService(IUsersRepository usersrepository)    //通过构造函数注入
15         {
16             _usersrepository = usersrepository;
17         }
18
19         /// <summary>
20         /// 获取用户是否存在
21         /// </summary>
22         /// <param name="criteria"></param>
23         /// <returns></returns>
24         public int GetUserIsExists(UsersEntity criteria)
25         {
26             return _usersrepository.GetUserIsExists(criteria);
27         }
28     }

在Api接口项目中创建一个AutoFac工具类：AutofacUtil.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
1     public class AutofacUtil
2     {
3         private static IContainer _container;
4
5         public static void ConfigureContainer()
6         {
7             #region AutoFac IOC容器
8
9             var builder = new ContainerBuilder();
10
11             try
12             {
13                 //builder.RegisterControllers(Assembly.GetCallingAssembly());  //注册mvc控制器  需要引用package Autofac.Mvc
14
15                 //builder.RegisterApiControllers(Assembly.GetExecutingAssembly()).PropertiesAutowired();  //支持Api控制器属性注入
16                 builder.RegisterApiControllers(Assembly.GetCallingAssembly());  //注册所有api控制器  构造函数注入  需要引用package Autofac.WebApi
17
18                 //注册程序集
19                 #region Service
20                 var assemblysServices = Assembly.Load("WebApi.Service");
21                 builder.RegisterAssemblyTypes(assemblysServices)
22                 .AsImplementedInterfaces()
23                 .InstancePerDependency();
24                 #endregion
25                
26                 #region Repository
27                 var assemblysRepository = Assembly.Load("WebApi.Repository");
28                 builder.RegisterAssemblyTypes(assemblysRepository)
29                 .AsImplementedInterfaces()
30                 .InstancePerDependency();
31                 #endregion
32
33                 _container = builder.Build();   //创建依赖注入
34
35
36                 //设置MVC依赖注入
37                 //DependencyResolver.SetResolver(new AutofacDependencyResolver(_container));
38
39                 //设置WebApi依赖注入
40                 GlobalConfiguration.Configuration.DependencyResolver = new AutofacWebApiDependencyResolver(_container);
41             }
42             catch (Exception ex)
43             {
44                 throw new Exception(ex.Message + "\n" + ex.InnerException);
45             }
46             #endregion
47         }
48
49         /// <summary>
50         /// 从Autofac容器获取对象
51         /// </summary>
52         /// <typeparam name="T"></typeparam>
53         /// <returns></returns>
54         public static T GetFromFac<T>()
55         {
56             return _container.Resolve<T>();
57         }
58
59     }

在 Global.asax.cs 全局中注册一下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1   public class WebApiApplication : System.Web.HttpApplication
2     {
3         protected void Application_Start()
4         {
5             AreaRegistration.RegisterAllAreas();
6             GlobalConfiguration.Configure(WebApiConfig.Register);
7             FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
8             RouteConfig.RegisterRoutes(RouteTable.Routes);
9             BundleConfig.RegisterBundles(BundleTable.Bundles);
10
11             //AutoFac 注册
12             AutofacUtil.ConfigureContainer();
13
14         }
15     }

最后在接口中使用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
1     public class UsersController : ApiController
2     {
3         private readonly IUsersService _usersService;
4         public UsersController(IUsersService usersService)    //使用构造函数注入
5         {
6             _usersService = usersService;
7         }
8
9
10         /// <summary>
11         /// 获取用户是否存在
12         /// </summary>
13         /// <param name="username"></param>
14         /// <param name="password"></param>
15         /// <returns></returns>
16         [HttpPost]
17         public IHttpActionResult GetUserIsExists(string username, string password)
18         {
19             //验证是否存在当前用户
20             var obModel = new UsersEntity()
21             {
22                 Username = username,
23                 Password = Encryption.MD5(password)
24             };
25             var getresult = _usersService.GetUserIsExists(obModel);
26
27             return Json(new { isexists = getresult > 0 });
28         }
29
30
31     }

测试结果：   最后：如果出现 未将对象引用的实例 的错 […]

C# WebRequest请求

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
using System;
using System.IO;
using System.Net;
using System.Text;
 
namespace w3cnet.Utils
{
    /// <summary>
    /// Web请求相关
    /// </summary>
    public class WebUtil
    {
        /// <summary>
        /// 获取公网url内容
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static string GetPage(string url)
        {
            return RequestGet(url);
        }
 
        /// <summary>
        /// Post请求
        /// </summary>
        /// <returns></returns>
        public static string RequestGet(string url)
        {
            //请求
            var request = (HttpWebRequest)WebRequest.Create(url);
            request.Timeout = 3600000; //3600秒
 
            //接收
            var response = request.GetResponse();
            var responseStream = response.GetResponseStream();
            if (responseStream != null)
            {
                var reader = new StreamReader(responseStream);
                var result = reader.ReadToEnd();
                reader.Close();
                response.Close();
 
                return result;
            }
 
            return string.Empty;
        }
 
        /// <summary>
        /// Post请求
        /// </summary>
        /// <returns></returns>
        public static string RequestPost(string url, string data = null, Encoding encoding = null)
        {
            if (encoding == null) encoding = Encoding.UTF8;
 
            //请求
            var request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = "POST";
            request.ContentType = "application/x-www-form-urlencoded";
 
            //参数
            if (!string.IsNullOrEmpty(data))
            {
                var byteArray = encoding.GetBytes(data);
 
                request.ContentLength = byteArray.Length;
 
                var requestStream = request.GetRequestStream();
                requestStream.Write(byteArray, 0, byteArray.Length);
                requestStream.Close();
            }
 
            //接收
            var response = request.GetResponse();
            var responseStream = response.GetResponseStream();
            if (responseStream != null)
            {
                var reader = new StreamReader(responseStream, encoding);
                var result = reader.ReadToEnd();
                reader.Close();
                response.Close();
 
                return result;
            }
 
            return string.Empty;
        }
    }
}

 

ABP(3.x)切换为MySQL

在EntityFrameworkCore项目下移除包Microsoft.EntityFrameworkCore.SqlServer 在EntityFrameworkCore项目下添加包Pomelo.EntityFrameworkCore.MySql v3.2.4 修改xxxDbContextConfigurer中的 删除EntityFraweorkCore下面的迁移文件夹 EntityFraweorkCore和WebHost的appsettings.json

1
2
3
"ConnectionStrings": {
    "Default": "server=127.0.0.1;database=abp;uid=root;pwd=123456;charset=utf8mb4;"
},

  添加数据迁移VS菜单：Tools -> NuGet Package Manager -> Package Manager Console运行以下命令：

1
Add-Migration DbName

  Update-Database Remove-Migration   from:https://blog.csdn.net/qq_40353040/article/details/108770993

java.security.egd

SecureRandom在java各种组件中使用广泛，可以可靠的产生随机数。但在大量产生随机数的场景下，性能会较低。这时可以使用"-Djava.security.egd=file:/dev/./urandom"加快随机数产生过程。 以产生uuid的时候使用nextBytes产生随机数为入口，xSecureRandom的代码逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public static UUID randomUUID() {
 
SecureRandom ng =Holder.numberGenerator;
 
 
 
byte[] randomBytes = newbyte[16];
 
ng.nextBytes(randomBytes);
 
randomBytes[6] &= 0x0f; /* clear version */
 
randomBytes[6] |=0x40; /* set to version 4 */
 
randomBytes[8] &= 0x3f; /* clear variant */
 
randomBytes[8] |=0x80; /* set to IETF variant */
 
return newUUID(randomBytes);
 
}
 

使用了SecureRandom.next*的方法。 在使用SecureRandom产生下一个随机数的时候调用nextLong或者nextBytes，最终会调用SecureRandom的nextBytes。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public long nextLong() {
 
// it's okay that the bottom wordremains signed.
 
return ((long)(next(32)) << 32)+ next(32);
 
}
 
 
 
final protected int next(int numBits) {
 
int numBytes = (numBits+7)/8;
 
byte b[] = new byte[numBytes];
 
int next = 0;
 
 
 
nextBytes(b);
 
for (int i = 0; i < numBytes; i++)
 
next = (next << 8)+ (b[i] & 0xFF);
 
return next >>> (numBytes*8 -numBits);
 
}
 

而nextBytes是一个同步的方法，在多线程使用时，可能会产生性能瓶颈。

1
2
3
4
5
synchronized public void nextBytes(byte[] bytes) {
 
secureRandomSpi.engineNextBytes(bytes);
 
}

  secureRandomSpi被初始化为sun.security.provider.SecureRandom secureRandomSpi是Secure […]

如何用Docker打包Springboot的四种方式

一:最基本的Dockerfile构建Springboot项目 在pom同目录下新建Dockerfile

1
2
3
4
FROM openjdk:8-jdk-alpine
VOLUME /tmp
COPY target/*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

  将Springboot使用Maven打包，在终端中传参进去，进行构建Images。

1
2
3
docker build --build-arg=target/*.jar -t demo1/app .
#构建完成后启动容器
docker run -p 8080:8080 demo1/app

  给Springboot启动时候传环境变量或者shell参数

1
2
3
4
5
FROM openjdk:8-jdk-alpine
VOLUME /tmp
ARG JAR_FILE
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["sh", "-c", "java ${JAVA_OPTS} -jar /app.jar ${0} ${@}"]

  指定JVM参数和shell参数

1
docker run -p 9000:9000 -e "JAVA_OPTS=-Ddebug -Xmx128m" demo1/app --server.port=9000

  二：使用Idea可视化管理docker， 构建Springboot容器 这个在我另外一篇文章有讲到，都比较简单，有啥问题请留言。 三：使用Maven插件自动化构建Image https://github.com/spotify/dockerfile-maven ，能力强的可以直接去看README.md。 简单介绍一下这个插件做啥用的 通过pom配置docker构建Image过程，参数等 。 封装了 […]

SpringBoot 部署 docker 打包镜像

环境： 1、代码编写工具：IDEA 2、打包：maven 3、docker 4、linux 7、JDK1.8 8、Xshell 9、Xftp 第一步：使用idea创建简单的springboot项目 第二步：设置项目生成jar包(两种方式) 1、修改pom文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
 
    <groupId>com.example</groupId>
    <artifactId>ordinary</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>
 
    <name>ordinary</name>
    <description>Demo project for Spring Boot</description>
 
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
 
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>
 
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
 
</project>

2、或者在生成项目的时候 可以选择jar和war 第三步：使用maven 生成包 (使用idea不用命令 直接界面操作就可以(如果Maven设置没问题 直接就可以生成 包 log会提示生成后的文件目录))   第四步：docker概念 1、docker：最早是dotCloud公司出品的一套容器管理工具，但后来Docker慢慢火起来了，连公司名字都从dotCloud改成Docker。 2、dockerfile：它是Docker镜像的描述文件，可以理解成火箭发射的A、B、C、D……的步骤。 3、docker镜像：通过Dockerfile做出来的，包含操作系统基础文件和软件运行环境，它使用分层的存储方式。 4、docker容器：是运行起来的镜像，简单理解，Doc […]

Docker部署SpringBoot项目

1.创建springboot项目   创建springboot项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package com.eangulee.demo.controller;
 
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
 
@Controller
public class HelloController {
    @RequestMapping("/")
    @ResponseBody
    public String hello() {
        return "Hello, SpringBoot With Docker";
    }
}

  2.打包springboot项目为jar包 3. 编写Dockerfile文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Docker image for springboot file run
# VERSION 0.0.1
# Author: eangulee
# 基础镜像使用java
FROM java:8
# 作者
MAINTAINER eangulee <eangulee@gmail.com>
# VOLUME 指定了临时文件目录为/tmp。
# 其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp
VOLUME /tmp
# 将jar包添加到容器中并更名为app.jar
ADD demo-0.0.1-SNAPSHOT.jar app.jar
# 运行jar包
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

  解释下这个配置文件： VOLUME 指定了临时文件目录为/tmp。其效果是在主机 /var/lib/docker 目录下创建了一个临时文件，并链接到容器的/tmp。该步骤是可选的，如果涉及到文件系统的应用就很有必要了。/tmp目录用来持久化到 Docker 数据文件夹，因为 Spring Boot 使用的内嵌 Tomcat 容器默认使用/tmp作为工作目录 项目的 jar 文件作为 “app.jar” 添加到容器的 ENTRYPOINT 执行项目 app.jar。为了缩短 Tomcat 启动时间，添加一个系统属性指向 “/dev/./urandom” 作为 Entropy Source 如果是第一次打包，它会自动下载java 8的镜像作为基础镜像，以后再制作镜像的时候就不会再下载了。 […]

MySQLHelper/Util类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
using System;
using System.Collections.Generic;
using System.Configuration;
using MySql.Data.MySqlClient;
using System.Data;
 
namespace Utils
{
    /// <summary>
    /// MySQL数据库工具类
    /// </summary>
    public abstract class MySQLUtil
    {
        /// <summary>
        /// 数据库连接字符串
        /// </summary>
        public static readonly string ConnStr = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
 
        /// <summary>
        /// 执行语句并返回影响的行数
        /// </summary>
        /// <param name="connStr">数据库连接字符串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>影响的行数</returns>
        public static int ExecuteNonQuery(string connStr, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            using (var conn = new MySqlConnection(connStr))
            {
                return ExecuteNonQuery(conn, cmdType, cmdText, parameters);
            }
        }
 
        /// <summary>
        /// 执行语句并返回影响的行数
        /// </summary>
        /// <param name="conn">数据库连接</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>影响的行数</returns>
        public static int ExecuteNonQuery(MySqlConnection conn, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            using (var cmd = new MySqlCommand())
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, parameters);
 
                var val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
 
                return val;
            }
        }
 
        /// <summary>
        /// 执行语句并返回影响的行数
        /// </summary>
        /// <param name="trans">事务</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>影响的行数</returns>
        public static int ExecuteNonQuery(MySqlTransaction trans, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            using (var cmd = new MySqlCommand())
            {
                PrepareCommand(cmd, trans.Connection, trans, cmdType, cmdText, parameters);
                var val = cmd.ExecuteNonQuery();
                cmd.Parameters.Clear();
 
                return val;
            }
        }
 
        /// <summary>
        /// 执行语句并返回DataReader对象
        /// </summary>
        /// <param name="connStr">数据库连接字符串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>执行语句并返回DataReader对象</returns>
        /// <remarks>P.S：DataReader使用后要手动释放</remarks>
        public static MySqlDataReader ExecuteReader(string connStr, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            var cmd = new MySqlCommand();
            var conn = new MySqlConnection(connStr);
 
            try
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, parameters);
                var dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
                cmd.Parameters.Clear();
 
                return dr;
            }
            catch
            {
                conn.Close();
                throw;
            }
        }
 
        /// <summary>
        /// 执行语句并返回DataSet对象
        /// </summary>
        /// <param name="cmdText"></param>
        /// <param name="parameters"></param>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(string cmdText, params MySqlParameter[] parameters)
        {
            return ExecuteDataSet(ConnStr, CommandType.Text, cmdText, parameters);
        }
 
        /// <summary>
        /// 执行语句并返回DataSet对象
        /// </summary>
        /// <param name="connStr">数据库连接字符串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>执行语句并返回DataSet对象</returns>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(string connStr, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            using (var conn = new MySqlConnection(connStr))
            {
                return ExecuteDataSet(conn, cmdType, cmdText, parameters);
            }
        }
 
        /// <summary>
        /// 执行语句并返回DataSet对象
        /// </summary>
        /// <param name="connStr">数据库连接字符串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>执行语句并返回DataSet对象</returns>
        /// <returns></returns>
        public static DataSet ExecuteDataSet(MySqlConnection conn, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            using (var cmd = new MySqlCommand())
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, parameters);
                using (var da = new MySqlDataAdapter(cmd))
                {
                    var ds = new DataSet();
                    try
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (MySqlException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }
 
        /// <summary>
        /// 执行语句并返回一个对象
        /// </summary>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>返回一个object对象，对象中只包含一列。</returns>
        public static object ExecuteScalar(string cmdText, params MySqlParameter[] parameters)
        {
            return ExecuteScalar(ConnStr, CommandType.Text, cmdText, parameters);
        }
 
        /// <summary>
        /// 执行语句并返回一个对象
        /// </summary>
        /// <param name="connStr">数据库连接字符串</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>返回一个object对象，对象中只包含一列。</returns>
        public static object ExecuteScalar(string connStr, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            using (var conn = new MySqlConnection(connStr))
            {
                return ExecuteScalar(conn, cmdType, cmdText, parameters);
            }
        }
 
        /// <summary>
        /// 执行语句并返回一个对象
        /// </summary>
        /// <param name="conn">数据库连接</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="parameters">参数集</param>
        /// <returns>返回一个object对象，对象中只包含一列。</returns>
        public static object ExecuteScalar(MySqlConnection conn, CommandType cmdType, string cmdText, params MySqlParameter[] parameters)
        {
            using (var cmd = new MySqlCommand())
            {
                PrepareCommand(cmd, conn, null, cmdType, cmdText, parameters);
                var val = cmd.ExecuteScalar();
                cmd.Parameters.Clear();
                return val;
            }
        }
 
        /// <summary>
        /// 为执行准备命令对象
        /// </summary>
        /// <param name="cmd">command 对象</param>
        /// <param name="conn">连接对象</param>
        /// <param name="trans">事务对象</param>
        /// <param name="cmdType">命令类型</param>
        /// <param name="cmdText">命令字符串</param>
        /// <param name="cmdParms">参数集</param>
        private static void PrepareCommand(MySqlCommand cmd, MySqlConnection conn, MySqlTransaction trans, CommandType cmdType, string cmdText, IEnumerable<MySqlParameter> parameters)
        {
 
            if (conn.State != ConnectionState.Open)
                conn.Open();
 
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
 
            if (trans != null)
                cmd.Transaction = trans;
 
            cmd.CommandType = cmdType;
 
            if (parameters == null) return;
            foreach (var parm in parameters)
                cmd.Parameters.Add(parm);
        }
    }
}

 

检测到有潜在危险的 Request.Form 值

这种问题是因为你提交的Form中有HTML字符串，例如你在TextBox中输入了html标签，或者在页面中使用了HtmlEditor组件等，解决办法是禁用validateRequest。 如果你是.net 4.0或更高版本，一定要看方法3。 此方法在asp.net webForm和MVC中均适用 方法1： 在.aspx文件头中加入这句：

1
<%@ Page validateRequest="false"  %>

  方法2： 修改web.config文件:

1
2
3
4
5
<configuration>
    <system.web>
        <pages validateRequest="false" />
    </system.web>
</configuration>

因为validateRequest默认值为true。只要设为false即可。   方法3： web.config里面加上

1
2
3
<system.web>
    <httpRuntime requestValidationMode="2.0" />
</system.web>

因为4.0的验证在HTTP的BeginRequest前启用，因此，请求的验证适用于所有ASP.NET资源，aspx页面,ashx页面,Web服务和一些HTTP处理程序等.   from:https://www.cnblogs.com/youring2/p/3559 […]