44444

44444

使用Mybatis实现数据库编程---在一个项目中，除了关联表，绝大部分的数据表都至少需要实现以下功能

插入1条数据

批量插入数据

根据id删除某一条数据

根据若干个id批量删除某些数据

根据id修改数据

统计当前表中数据的数量

根据id查询数据详情

查询当前表中的数据列表

一、在配置类中使用@MapperScan指定接口文件所在的根包，在项目的根包下创建config.MybatisConfiguration配置类(添加了

@Configuration注解的类)，在此类上配置@MapperScan注解

二、在配置文件中通过mybatis.mapper-locations属性来指定XML文件所在的位置，在application.properties中添加配置

mybatis.mapper-locations=classpath:mapper/*.xml，然后在src/main/resources下创建mapper文件夹

xml version="1.0" encoding="UTF-8"?>

-//mybatis.org//DTD Mapper 3.0//EN" "" target="_blank">http://mybatis.org/dtd/mybatis-3-mapper.dtd"" target="_blank">>

三、创建实体类，在项目根包下创建实体类pojo.entity.Album，在类中声明与数据表对应的各属性。在编写pojo类之前，先在项目

中添加依赖

org.projectlombok

lombok

1.18.20

provided

在任何pojo类上，可以添加@Data注解，则Lombok框架会自动在编译期生成getter、setter、hashcode、equals方法

另外任何pojo类，都应该实现Serializable接口。

四、创建接口，并声明抽象方法。在项目的根包下创建mapper.AlbumMapper接口，并在接口中添加"插入1条数据"的抽象方法

public interface AlbumMapper{

int insert(Album album);

}

五、添加XML文件，并在此文件中配置抽象方法映射的SQL语句。在src/main/resources/mapper下，

六、创建测试类，编写并执行测试方法，在src/test/java下的根包下，创建mapper.AlbumMapperTests类，在类上添加

@SpringBootTest注解，并在类中编写测试方法

MySQL数据类型与Java类中的数据类型的对应关系-----

tinyint/smallint/intInteger

bigintLong

char/varchar/text系列String

date_timeLocalDateTime

关于抽象方法的声明--

返回值类型：如果执行的SQL语句是增、删、改类型的，返回值类型始终使用int，表示"受影响的行数"，不建议使用void

方法的名称：参考阿里编码规范，且不推荐重载

参数的列表：根据需要执行的SQL语句中的参数来设计，如果参数较多且具有相关性，则推荐封装

密码加密----用户注册时(管理员添加新的账号信息时)的密码必须经过某种算法进行编码，并将得到的结果存储到数据库，而不允许

将原始密码直接存储到数据库中。原始密码通常可以称之为密码的原文，或称之为明文密码，经过编码处理的结果可

称之为密文。

如果直接存储明文密码，容易导致用户账号被窃取的安全问题，基于当下主流的网络技术，这类安全问题通常是企业

内部管理问题导致的！简单来说，对密码进行加密处理，主要防的就是内部员工(例如能够直接接触到数据库服务器的

员工，无论是进入机房或是远程登录)

对明文密码进行编码处理时，不可以使用任何加密算法！因为所有加密算法都是可以逆向运算的，即根据算法类型、加密

参数、密文，可以通过运算得到原文。通常，加密算法只是用于保障数据在传输过程中的安全性！

对于需要存储下来的密码，且只需要验证原密码是否匹配，不需要(不允许)通过逆向运算根据密文得到原文时，应该使

用消息摘要算法对密码原文进行编码处理

消息摘要算法的典型特征：

消息相同时，摘要必然相同

使用固定的某种消息摘要算法，无论消息的长度多少，摘要的长度是固定的

消息不同时，摘要极大概率不会相同，理论上必然存在N个不同的消息，通过编码得到的摘要是完全相同的

由于摘要的种类也非常多，设计得非常好的算法会使得这种概率非常低

所有消息摘要算法都是不可以逆向运算的

消息摘要算法的结果通常会使用十六进制数来表示，通常，运算结果相对简单的消息摘要算法的结果长度也有32位

十六进制数组成，还原成二进制数就是128个二进制数组成，这样的算法称之"128位算法"，同理，如果某个

结果是由64个十六进制数组成，还原成二进制数就是256个二进制数，则称之为"256位算法"

在Spring Boot项目中，已有DigestUtils工具类中的md5DigestAsHex()方法提供了MD5算法进行编码

Lombok框架--@Data：添加在类上，可以在编译期生成getter、setter、hashcode、toString、equals方法等，使用此注解，必须保证

当前类的父类存在无参构造方法

@Setter：可以加在属性上，也可以添加在类上

@Getter：同@Setter

@EqualsAndHashCode：添加在类上，生成规范的equals和hashcode方法

@ToString：添加在类上

@Slf4j：添加在类上添加，日志注解，可以添加在测试类上

Slf4j日志---在Spring Boot项目中，基础依赖项(spring-boot-starter)中已经包含了日志的相关依赖项

在添加了Lombok依赖项后，可以在类上添加@Slf4j注解，则Lombok框架会在编译期生成名为log的变量，可调用此变量

的方法来输出日志

显示级别：根据日志内容的重要程度，从不重要到重要依次为————

trace：跟踪信息，可能包含不一定关注，但是包含了程序执行流程的信息

debug：调试信息，可能包含一些敏感内容，比如关键的数据的值

info ：一般信息

warn ：警告信息

error：错误信息

在Spring Boot项目中，默认的日志显示级别为【info】，将只会显示application.properties中配置

logging.level.根包=日志显示级别 来设置当前显示级别

在开发实践中，应该使用trace或debug级别的日志来输出与流程相关的、涉及敏感数据的日志，使用info输出一般的、

被显示在控制台也无所谓的信息，使用warn和error输出更加重要的需要关注的日志

输出日志时，通常建议使用void trace(String message,Object... args)方法(也有其他级别日志的同样参数列表的方法)

在第1个参数String message中可以使用{}作为占位符，表示某变量的值。后面可以跟N个值，类似于Vue的插值

Profile配置-同一个项目，在不同的环境中，需要的配置值可能是不同的，例如日志的显示级别、连接数据库的配置参数等，由Spring

框架提供，在Spring Boot中更是简化了此项操作，它允许使用application-自定义名称.properties作为Profile配置文件

的文件名

这类配置文件默认不会加载，在applicaton.properties中通过spring.profiles.active=自定义名称 来激活配置文件

当主从配置文件配置冲突时，以从文件配置为准(范围越小越优先)

YAML配置----是一种编写配置文件的语法，表现为使用.yml作为扩展名的配置文件，Spring框架默认不支持此类配置文件，而Spring

Boot的基础依赖项中已经包含解析此类文件的依赖项，所以在Spring Boot项目可以直接使用此类配置文件

在Spring Boot项目中，使用.properties和.yml配置是等效的

插入数据时获取自动编号的id--

如果表中的id是自动编号的，在标签上，可以配置useGeneratedKeys="true"和keyProperty="id",可以自动获取自动编号

的id值，并由Mybatis自动赋值到参数对象的对应的属性id上

批量插入多条数据----代码如下

INSERT INTO pms_album(

name,description,sort

)VALUES

(#{album.name},#{album.description},#{album.sort})

根据id更新一条数据--代码如下，Mybatis的标签会自动去掉if判断完后最后一个值的逗号

UPDATE pms_album

name=#{name},

description=#{description},

sort=#{sort},

WHERE id=#{album.id}

查询----每个标签必须配置resultType或resultMap中的一个，如果使用resultMap，则在resultMap中须使用type来指定结果类型

查询的一般写法--建议使用标签来封装查询的字段列表，并通过标签来引用，代码如下

SELECT

FROM pms_category

WHERE id=#{id}

id,name,parent_id,depth,keywords,sort,icon,enable,is_parent,is_display

关于Service-----在项目中，应该使用Service组件来处理业务相关的代码，以此来设计业务流程、业务逻辑，以保证数据的完整性、

有效性。

通常，Service应该由接口和实现类来组成，实现类上要加@Service注解

Service抽象方法的声明原则————

返回值类型：仅以操作成功为前提来设计，操作失败用通过抛出异常来表示，异常应继承自RuntimeException

方法名称 ：自定义的、规范的，无其它约束

参数列表 ：根据客户端提交的请求参数来设计，如果参数较多，且具有相关性，则应该封装

添加相册的业务--先制定业务规则：相册名称必须是唯一的

处理添加相册请求----开发控制器相关代码时，需要项目中添加spring-boot-starter-web依赖项，此依赖项包含了

spring-boot-starter依赖项

关于处理异常----在服务器端项目中，如果某个抛出的异常始终没有被处理，则默认会向客户端响应500状态代码

所以在服务器端项目中，必须对异常进行处理，因为如果不处理，软件的使用者可能不清楚出现异常的原因，也不

知道如何调整请求参数来解决此问题，甚至可能反复尝试提交错误的请求(刷新页面)，对于服务器端而言，也是浪费

了一些性能

Spring MVC框架统一处理异常的机制----

每种类型的异常只需要编写1段相关的处理代码即可，当使用这种机制时，在各处理请求的方法中，将不再使用try-catch语句

块来包裹可能抛出异常的方法并处理，则控制器类中处理请求的方法都将是抛出异常的(虽然不必在代码中显示的throws)，

这些异常会被Spring MVC框架捕获并尝试调用统一处理异常的方法如下：

注解 ：必须添加@ExceptionHandler注解

访问权限 ：public

返回值类型：参考处理请求的方法

方法名称 ：自定义

参数列表 ：必须有1个异常类型的参数，表示Spring MVC框架调用处理请求的方法时捕获的异常，并且，可以按需添加

HttpServletRequest、HttpServletResponse等少量特定类型的参数，不可以随意添加其他参数

一般会将统一处理异常的代码放在专门的类中，并在此类上添加@RestControllerAdvice注解，此类中特定的方法将作用于整个

项目任何处理请求的过程

限制请求方式----以获取数据为主要目的的用get，其他用post

在RequestMapping(value="/reg",method=RequestMethod.POST)设置该方法只能允许post请求

Spring MVC框架已经定义了限制请求方式的注解，只能添加在方法上：

@GetMapping ：把请求方式限制为get

@PostMapping：把请求方式限制为post

@PutMapping：把请求方式限制为put

@DeleteMapping:把请求方式限制为delete

@PatchMapping :把请求方式限制为patch

关于RESTful-----是一种软件的设计风格(不是规定，也不是规范)

典型表现：一定是响应正文的，服务器端处理完请求后将响应数据，不会由服务器响应页面到客户端

通常会将具有唯一性的请求参数设计到url中，成为url的一部分

严格区分4种请求方式，在许多业务系统其实并不这样设计，增加数据使用post、删除数据

使用delete、修改数据使用put、查询数据使用get

Spring MVC框架很好的支持了RESTful风格的设计，当需要在url中使用变量值时，可以使用{自定义名称}

作为占位符，同时如果想拿到传过来的参数，可以在参数列表添加@PathVariable注解，并声明对应

的变量来接收，通常会将占位符中的自定义名称和方法的参数名称保持一致，如果因为某些原因

无法保持一致，则需要配置@PathVariable("参数")，此注解参数与占位符一致即可

在开发实践中，可以将处理请求的方法的参数类型设计为期望的类型，例如将id设计为Long类型的

但是，如果这样设计，必须保证请求中的参数值是可以被正确转换为Long类型的，否则会出现400错误

为了尽量保证匹配的准确性、保证参数值可以正常转换，在设计占位符时，可以在占位符名称右侧添加冒号

并在冒号右侧使用正则表达式来限制占位符的值的格式

// http://localhost:8080/album/9527/delete

@RequestMapping("/{id:[0-9]+}/delete")

public String delete(@PathVariable Long id){

String message = "尝试删除id值为"+id+"的相册";

log.debug(message);

return message;

}

一旦使用正则表达式后，多个不冲突的占位符的设计是允许共存在的，例如：

// http://localhost:8080/album/hello/delete

@RequestMapping("/{id:[a-z]+}/delete")

public String delete(@PathVariable String name){

String message = "尝试删除id值为"+id+"的相册";

log.debug(message);

return message;

}

另外，没有使用占位符的设计，与使用了占位符的设计，也是允许共存的，例如：

// http://localhost:8080/album/test/delete//精准匹配优先级是最高的

@RequestMapping("/test/delete")

public String delete(@PathVariable Long id){

String message = "尝试删除id值为"+id+"的相册";

log.debug(message);

return message;

}

最后，关于RESTful风格的url设计，如果没有明确的要求，或没有更好的选择，可以设计为：

获取数据列表 ：/albums

根据id获取数据 ：/albums/1

根据id对数据执行某种操作：/albums/1/delete

关于Knife4j框架-----是一款基于Swagger 2的在线API文档框架，使用Knife4j框架需要：

添加依赖，注意：本次使用的Knife4j必须基于Spring Boot的版本在2.6之前(2.6及更高的版本不可用)

com.github.xiaoymin

knife4j-spring-boot-starter

2.0.9

需要在主配置文件中添加配置

knife4j.enable=true

添加配置类

package cn.tedu.jsd2207csmall.product.config;

import com.github.xiaoymin.knife4j.spring.extension.OpenApiExtensionResolver;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.ApiInfoBuilder;

import springfox.documentation.builders.PathSelectors;

import springfox.documentation.builders.RequestHandlerSelectors;

import springfox.documentation.service.ApiInfo;

import springfox.documentation.service.Contact;

import springfox.documentation.spi.DocumentationType;

import springfox.documentation.spring.web.plugins.Docket;

import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;

/**

* Knife4j配置类

*

* @author [email protected]

* @version 0.0.1

*/

@Slf4j

@Configuration

@EnableSwagger2WebMvc

public class Knife4jConfiguration {

/**

* 【重要】指定Controller包路径

*/

private String basePackage = "cn.tedu.jsd2207csmall.product.controller";

/**

* 分组名称

*/

private String groupName = "product";

/**

* 主机名

*/

private String host = "http://java.tedu.cn";

/**

* 标题

*/

private String title = "酷鲨商城在线API文档--商品管理";

/**

* 简介

*/

private String description = "酷鲨商城在线API文档--商品管理";

/**

* 服务条款URL

*/

private String termsOfServiceUrl = "http://www.apache.org/licenses/LICENSE-2.0";

/**

* 联系人

*/

private String contactName = "Java教学研发部";

/**

* 联系网址

*/

private String contactUrl = "http://java.tedu.cn";

/**

* 联系邮箱

*/

private String contactEmail = "[email protected]";

/**

* 版本号

*/

private String version = "1.0.0";

@Autowired

private OpenApiExtensionResolver openApiExtensionResolver;

public Knife4jConfiguration() {

log.debug("创建配置类对象：Knife4jConfiguration");

}

@Bean

public Docket docket() {

String groupName = "1.0.0";

Docket docket = new Docket(DocumentationType.SWAGGER_2)

.host(host)

.apiInfo(apiInfo())

.groupName(groupName)

.select()

.apis(RequestHandlerSelectors.basePackage(basePackage))

.paths(PathSelectors.any())

.build()

.extensions(openApiExtensionResolver.buildExtensions(groupName));

return docket;

}

private ApiInfo apiInfo() {

return new ApiInfoBuilder()

.title(title)

.description(description)

.termsOfServiceUrl(termsOfServiceUrl)

.contact(new Contact(contactName, contactUrl, contactEmail))

.version(version)

.build();

}

}

完成后，重新启动项目，可以通过 http://localhost:8080/doc.html 查看在线API文档并可使用其中的调用功能等

在使用Knife4j时，应该使用相关注解，将API文档配置得更加易于阅读和使用：

@Api：添加在控制器类上，通过此注解的tags属性，可以指定模块名称，并且可以在模块名称前自行

添加数字序号，以实现排序效果，框架会根据各控制器类的@Api注解的tags属性值进行升序

@ApiOperation：添加在处理请求的方法上，通过此注解的value属性，可以指定业务名称

@ApiOperationSupport：添加在处理请求的方法上，通过此注解的order属性(数值型)，可以指定

排序序号，框架会根据此属性值升序排列

通常指定order属性为三位数，且1开头代表insert操作

2开头代表delete操作

3开头代表update操作

4开头代表select操作

9开头代表废弃的操作

@ApiModelProperty：添加在DTO、VO类的属性上，配置属性的名称和是否可以为空，也可以加在响应结果上

@ApiModelProperty(value="相册名称",required=true)

@ApiImplicitParam：添加在处理请求的方法上，配置不是pojo类型的参数

@ApiImplicitParam(name="id",value="相册id",required=true,dataType="long")

@ApiImplicitParams：添加在处理请求的方法上，配置多个不是pojo类型的参数

@ApiImplicitParams({数组里面放多个@ApiImplicitParam注解})

安装Node.js-----搭建前端项目的仓库管理器，下载Node.js后并安装

npm -v查看是否安装成功

npm config set registry https://registry.npmmirror.com配置npm源

npm config get registry查看npm源

安装VUE Cli-----本项目的前端项目将使用"Vue脚手架"项目来开发，必须先在本机安装Node.js，然后在cmd中输入

npm install -g @vue/cli安装vue脚手架

vue -V检查vue脚手架是否安装完成

如果卡住了，Ctrl+C强行终止，并再次尝试安装

创建Vue脚手架项目---在创建项目之前，先确定当前操作位置，例如：C:\Users\tarena，此操作位置决定项目创建位置

通过vue create +项目名称即可创建项目，例如：vue create jsd-csmall-web-client，按回车等待

接下来选择项目的参数① Manually select features

② Babel、Router、Vuex

③ 2.x

④ In package.json

然后把创建好的项目剪切到常用的文件夹，然后在idea中打开，在终端面板中npm run serve启动项目，然后

根据提示的url在浏览器中打开可以看到默认的页面，前端项目没有终止按钮，只能在终端面板Ctrl+C

配置前后端端口--避免每次启动项目端口不一样发生冲突，在后端的从配置文件中配置后端端口server.port=9080

在前端项目的package.json中在serve值的后面手动指定端口为 -- 9000

关于视图组件----以.vue为拓展名的文件称之为"视图组件"，将负责页面的显示，包括编写样式、JavaScript代码，一定程度上，与

传统项目中的.html文件的作用是相似的，主要由3部分组成：

：用于设计页面元素，即页面需要显示什么，此标签有且只有一个直接子标签

：用于设计样式规则，即CSS

：用于编写JavaScript程序

默认的页面效果--与运行效果相关的常用文件有：

src/App.vue：是项目中唯一的.html文件默认绑定的视图组件，可理解为项目的入口视图组件，并且，此页面

中设计的内容是始终显示的，在此视图中，有标签，此标签表示"将由其他

视图组件来显示"

src/router/index.js：是默认的路由配置文件，此文件中的routes常量配置了路径与视图组件的对应关系，决定了

标签将由哪个视图组件来显示

关于routes的配置：此属性是数组类型的，其中的各元素通常称之为一个个的"路由对象"，每个路由对象中主要

配置path和component属性，即配置路径与视图组件的对应关系，关于component，如果某个

视图是类似"主页"定位，推荐通过import语句导入，其它视图推荐使用import()函数导入

Vue脚手架项目的结构-----[.idea] ：是通过idea编辑项目时，由idea创建的文件夹，不需要人为干预

[node_modules]：当前项目的依赖项文件夹，不应该人为干预，在使用Git等管理工具时，通常并不会将

此文件夹提交到Git服务器，从Git服务器下载得到的项目也不会包含此文件夹及内容，

如果没有这个文件夹，则项目无法编译、运行。可以通过执行npm install命令安装

项目所需的依赖项

[public] ：静态资源文件夹，此文件夹下的内容是可以直接被访问的，不会经过项目的编译过程，

通常会在此文件下存放css、js、图片文件等

favicon.ico：当前网站的图标文件，此文件是固定文件名的

index.html ：当前项目中仅有的唯一.html文件

[src] ：项目的源代码文件夹

[assets]：静态资源文件夹，与public文件夹不同，此处的静态资源应该是不随程序

运行而变化的

[components]：被其它视图导入、调用的视图组件的文件夹

[views] ：视图组件文件夹

[router]：路由配置文件的文件夹

index.js：默认的路由配置文件

[store] ：存储全局的量的文件所在的文件夹

index.js：默认的存储全局的量的文件

App.vue ：直接绑定到了index.html的视图组件

main.js ：项目的主配置文件

.gitignore ：用于配置"提交Git时忽略哪些文件、文件夹"

babel.config.js：暂不关心

jsconfig.json ：暂不关心

LICENSE ：作为Git的开源项目应该包含"许可协议"，此文件就是"许可协议"文件

package.jsion ：当前项目的配置文件，类似Maven项目中的pom.xml文件，不建议手动修改

package-lock.json：锁定的当前项目配置文件，此文件不允许手动编辑，即使编辑了，也会自动还原

安装并配置ELEMENT UI----在终端窗口中执行npm i element-ui -S

需要在main.js中添加配置：

import ElementUI from 'element-ui';

import 'element-ui/lib/theme-chalk/index.css';

Vue.use(ElementUI);

嵌套路由----在设计前端的视图组件时，如果根级视图(通常是App.vue)使用了则表示相关区域将由另一个视图组件

来完成显示，而另一个视图组件中也使用了就会出现的嵌套，则需要在router/index.js

中配置嵌套路由。可以给路由对象配置children属性，此属性配置方式与routes完全一样

安装axios---npm i axios -S

然后在main.js中添加配置：

import axios from 'axios';

Vue.prototype.axios = axios;

跨域访问----客户端与服务端不在同一台主机上，在默认情况下，不允许发送跨域访问请求

在Spring Boot项目中，需要使用配置类实现WebMvcConfigurer接口，并重写addCorsMappings()方法进行配置

public void addCorsMappings(CorsRegistry registry) {

registry.addMapping("/**")

.allowedOriginPatterns("*")

.allowedHeaders("*")

.allowedMethods("*")

.allowCredentials(true)

.maxAge(3600);

}

@RequestBody----在Spring MVC项目中(包括添加了spring-boot-starter-web依赖项的Spring Boot项目)，可以在处理请求的方法

的参数列表中，在某参数上添加@RequestBody注解。如果请求参数添加了@RequestBody注解，则客户端提供的

请求参数必须是对象格式。

如果请求参数没添加@RequestBody注解，则客户端提供的请求参数必须是FormData格式

使用qs------是一款可以将对象格式的数据转换为FormData格式的框架，npm i qs -S

然后在main.js中添加配置：

import qs from 'qs';

Vue.prototype.qs=qs;

let formData = this.qs.stringify(this.ruleForm)

响应JSON格式字符串--在Spring Boot项目中，只需要自定义类型，在此类型中设计响应结果中包含的数据属性，并在处理请求、处理

异常的方法上使用此类型作为返回值类型即可,在类上加@Data注解

检查请求参数----所有请求参数都应该对数据的基本格式进行检查，此类检查可以在客户端直接进行，但是，对于服务器端而言，客户

端的检查结果应该视为"不信任的"，因为可能某些请求是绕过了客户端的检查的，客户端软件可能存在被篡改，

客户端软件可能不是最新版本，与服务器期望的并不一致，以及其它原因

所以服务器端必须在接收到请求参数的第一时间，就对请求参数的基本格式进行检查

使用Validation--来检查请求参数的基本格式，先添加依赖项

org.springframework.boot

spring-boot-starter-validation

在控制器中，对于封装类型的请求参数，应该先在请求参数之前添加@Valid或@Validated注解，表示将需要对此请求

参数的格式进行检查，然后在此封装的类型中，在需要检查的属性上，添加检查注解，例如：

@NotNull(message = "必须提交相册名称")非空检测，并自定义错误提示

当请求参数可能出现多种错误时，也可以选择"快速失败"的机制，它会使得框架只要发现错误，就停止检查其他规则

这需要在配置类ValidationConfiguration中进行配置如下：

//Builder模式

//链式语法

@Bean

public Validator validator(){

return Validation.byProvider(HibernateValidator.class)

.configure()

.failFast(true)

.buildValidatorFactory()

.getValidator();

}

当处理请求的方法的参数时未封装的(例如Long id)，检查时，需要：

在当前控制器类上添加@Validated注解

在需要检查的请求参数上添加检查注解@Range(min = 1,message = "删除相册失败，id无效")

关于检查注解----@NotNull ：非空检测

@Range ：整数数值范围检测

@NotEmpty：不允许长度为0的字符串

@NotBlank：不允许全部为空白字符

@Pattern ：此注解有regexp属性，配置正则表达式

除了@NotNull注解以外，其他注解均不检查请求参数为null的情况

VUE生命周期方法-----created(){}刚刚创建出来

mounted(){}挂载，准备就绪，推荐使用

基于Spring JDBC的事务管理---事务(Transaction)，是关系型数据库中一种能够保障多个写操作(增、删、改)要么全部成功，要么

全部失败的机制

在编程式事务管理过程中，需要先开启事务(BEGIN)，然后执行数据操作，当全部完成，需要提交

事务(COMMIT)，如果失败，则回滚事务(ROLLBACK)

在基于Spring JDBC的项目中，只需要使用声明式事务即可，只需要在业务方法上添加

@Transactional注解，即可使得方法有事务性

Spring JDBC实现事务管理大致是：

开启事务：Begin

try{

执行事务方法：即数据访问操作

提交事务：Commit

}catch(RuntimeException e){

回滚事务：Rollback

}

所以，Spring JDBC在事务管理中，默认将基于RuntimeException进行回滚，可以通过@Transactional的

rollbackFor或rollbackForClassName属性来修改，例如：

@Transactional(rollback = {NullPointerException.class,IndexOutOfBoundsException.class})

@Transactional(rollbackForClassName = {"java.lang.NullPointerException",...})

还可以通过noRollbackFor或noRollbackForClassName属性来配置对于哪些异常不回滚

其实，@Transactional注解还可以添加在：

实现类上 ：作用于当前类中所有业务方法

实现类业务方法：作用于添加了注解的业务方法

接口上 ：作用于实现了此接口的类中的所有业务方法

接口业务方法 ：作用于实现了此接口的类中的重写的当前业务方法

如果都添加了，且配置了相同的参数，则范围越小越优先，推荐添加在接口或接口中的业务方法上

添加在测试方法上可以自动回滚

关于获取受影响行数--对于写操作，一般都要在业务方法获取受影响的行数，并判断是否与预期一致，如果不一致就抛出异常

int rows = categoryMapper.insert(category);

if(rows != 1){

String message = "添加类别失败，服务器繁忙，请稍后再尝试";

log.debug(message);

throw new ServiceException(ServiceCode.ERR_INSERT,message);

}

关于Spring Security框架-----主要解决了认证与授权相关的问题，先添加Spring Boot Security依赖项

org.springframework.boot

spring-boot-starter-security

关于Spring Security配置类---在Spring Boot项目中，创建config.SecurityConfiguration配置类，需要继承自

WebSecurityConfigurerAdapter，并重写configure(HttpSecurity http)方法进行配置

protected void configure(HttpSecurity http) throws Exception {

// 白名单

String[] urls = {

"/doc.html",

"/**/*.js",

"/**/*.css",

"/swagger-resources",

"/v2/api-docs"

};

// 将防止伪造跨域攻击的机制给禁用

http.csrf().disable();

// super.configure(http);

http.authorizeRequests() //管理请求授权

.mvcMatchers(urls)

.permitAll() //直接许可

.anyRequest() //除了以上配置过的其它所有请求

.authenticated(); //要求是"已通过认证的"

http.formLogin(); //启用登录表单

}

关于伪造的跨域攻击--即CSRF主要是基于服务器端对浏览器的信任，在多选项卡的浏览器中，如果在X选项卡中登录，在Y选项卡中

的访问也会被视为"已登录"

在Spring Security框架中默认开启了防止伪造的跨域攻击的机制，其基本做法就是需要在POST请求中要求

客户端提交其随机生成的一个UUID值

关于登录账号----默认情况下，Spring Security框架提供了默认的用户名user和启动时随机生成的UUID密码，如果需要自定义登录

账号，可以自定义类，实现UserDetailsService接口，重写接口中的如下方法：

UserDetails loadUserByUsername(String username);

Spring Security框架在处理认证时，会自动根据提交的用户名(用户在登录表单中输入的用户名)来调用以上方法

以上方法应该返回匹配的用户详情(UserDetails类型的对象)，接下来，Spring Security会自动根据用户详情

(UserDetails对象)来完成认证过程，例如判断密码是否正确

在根包下创建security.UserDetailsServiceImpl类，在类上添加@Service注解，实现接口并重写方法：

public UserDetails loadUserByUsername(String s) throws UsernameNotFoundException {

if("root".equals(s)){

UserDetails userDetails = User.builder()

.username("root")

.password("1234")

.disabled(false)

.accountLocked(false)

.accountExpired(false)

.credentialsExpired(false)

.authorities("暂时给出的假权限标识")

.build();

log.debug("{}",userDetails);

return userDetails;

}

return null;

}

在Spring Security配置类中添加密码编码器(也可以添加BCrypt编码器，对应上面也要修改)：

@Bean

public PasswordEncoder passwordEncoder(){

return NoOpPasswordEncoder.getInstance();

}

使用前后端分离的登录模式----使用Service处理登录认证，调用AuthenticationManager的authenticate()方法处理认证，可以通过重写

配置类中的authenticationManagerBean()方法，并添加@Bean注解来得到，如下：

@Bean

@Override

public AuthenticationManager authenticationManagerBean() throws Exception {

return super.authenticationManagerBean();

}

@Autowired

private AuthenticationManager authenticationManager;

@Override

public void login(AdminLoginDTO adminLoginDTO) {

log.debug("开始处理【管理员登录】的业务，参数：{}", adminLoginDTO);

Authentication authentication

= new UsernamePasswordAuthenticationToken(

adminLoginDTO.getUsername(), adminLoginDTO.getPassword());

authenticationManager.authenticate(authentication);

简历技术描述参考----【了解/掌握/熟练掌握】开发工具的使用，包括：Eclipse、IntelliJ IDEA、Git、Maven

【了解/掌握/熟练掌握】Java语法

【理解/深刻理解】面向对象编程思想

【了解/掌握/熟练掌握】Java SE API，包括：String、日期、IO、反射、线程、网络编程、集合、异常等

【了解/掌握/熟练掌握】HTML、CSS、JavaScript前端技术

【了解/掌握/熟练掌握】前端相关框架技术及常用工具组件，包括：jQuery、Bootstrap

Vue脚手架、Element UI、axios、qs、富文本编辑器等

【了解/掌握/熟练掌握】MySQL的应用

【了解/掌握/熟练掌握】DDL、DML的规范使用

【了解/掌握/熟练掌握】数据库编程技术，包括：JDBC、数据库连接池（commons-dbcp、commons-dbcp2、Hikari、druid）

及相关框架技术，例如：Mybatis Plus等

【了解/掌握/熟练掌握】主流框架技术的规范使用，例如：SSM（Spring，Spring MVC， Mybatis）

Spring Boot、Spring Validation、Spring Security等

【理解/深刻理解】Java开发规范（参考阿里巴巴的Java开发手册）

【了解/掌握/熟练掌握】基于RESTful的Web应用程序开发

【了解/掌握/熟练掌握】基于Spring Security与JWT实现单点登录

关于登录的判断标准--在Spring Security框架中，对于登录的判断标准是：在SecurityContext中是否存在Authentication对象，如果

存在，Spring Security框架会根据Authentication对象识别用户的身份、权限等，如果不存在，视为未登录

在默认情况下，Spring Security框架也是基于Session来处理用户信息的

关于Session-----为了能够识别客户端身份，当某客户端第1次向服务器端发起请求时，服务器端将向客户端响应一个JSESSIONID数据

(其本质是一个UUID数据)，在客户端后续的访问中会自动携带此JSESSIONID，以至于服务器端能够识别客户端的身份

同时在服务器端还有一个Map结构的数据，此数据使用JSESSIONID作为key，所以每个客户端在服务器端都有一个与之

对应的在此Map中的value，也就是Session数据

缺点：不适合长时间保存数据，因为Session是内存中的数据，并且所有来访的客户端在服务器端都有对应的Session

数据，就必须存在Session清除机制，因为如果长期不清除，随着来访的客户端越来越多，将占用越来越多的

内存，通常会将Session设置为15分钟或最多30分钟清除

默认不适用于集群或分布式系统，因为Session是内存中的数据，所以默认情况下，Session只存在于与客户端

交互的那台服务器上，如果使用了集群，客户端每次请求的服务器都不是同一台服务器，则无法有效的识别

客户端的身份。【可以通过共享Session机制解决】

Token---票据、令牌

由于客户端种类越来越多，目前主流的识别用户身份的做法都是使用Token机制，Token可以理解为"票据"，例如现实生活中

的火车票，某客户端第1次请求服务器，或执行登录请求，即可视为购买火车票行为，当客户端成功登录，相当于成功购买

了火车票，客户端的后续访问应该携带Token，相当于乘坐火车需要携带购票凭证，则服务器端可以识别客户端的身份，相当

于火车站及工作人员可以识别携带了购买凭证的乘车人

与Session最大的区别在于：Token是包含可识别的有效信息的，长时间保存用户信息

JWT-----JSON WEB TOKEN，是一种使用Json格式来组织数据的Token，不能放隐私数据，先添加依赖项

io.jsonwebtoken

jjwt

0.9.1

void generate() {

Date date = new Date(System.currentTimeMillis() + 2 * 60 * 1000);

Map claims = new HashMap<>();

claims.put("id", 9527);

claims.put("username", "liucangsong");

String jwt = Jwts.builder()

.setHeaderParam("alg", "HS256")

.setHeaderParam("typ", "JWT")

.setClaims(claims)

.setExpiration(date)

.signWith(SignatureAlgorithm.HS256, secretKey)

.compact();

System.out.println(jwt);

}

void parse() {

String jwt = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpZCI6OTUyNywiZXhwIjoxNjY3ODc4ODEzLCJ1c2VybmFtZSI6ImxpdWNhbmdzb25nIn0.c_ZkBOHr2NAUSt2z0918jrNV-lbzPabFu1ClRviWuC0";

Claims claims = Jwts.parser()

.setSigningKey(secretKey)

.parseClaimsJws(jwt)

.getBody();

Object id = claims.get("id", Long.class);

Object username = claims.get("username", String.class);

System.out.println(id + "," + username);

}

登录成功时返回JWT---在处理登录时，当用户登录成功，应该向客户端返回JWT数据，以至于客户端下次提交请求时，可以携带JWT

来访问服务器端，需要自定义过滤器来接收客户端携带的JWT数据

@Component

public class JwtAuthorizationFilter extends OncePerRequestFilter {

public static final int JWT_MIN_LENGTH = 113;

public JwtAuthorizationFilter() {

log.debug("创建过滤器对象JwtAuthorizationFilter");

}

@Override

protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

log.debug("开始执行过滤");

String jwt = request.getHeader("Authorization");

log.debug("获取客户端携带的JWT：{}", jwt);

// 检查是否获取到了基本有效的JWT

if (!StringUtils.hasText(jwt) || jwt.length() < JWT_MIN_LENGTH) {

// 对于无效的JWT，直接放行，交由后续的组件进行处理

log.debug("获取到的JWT被视为无效，当前过滤器将放行······");

filterChain.doFilter(request, response);

return;

}

// 尝试解析JWT

log.debug("获取到的JWT被视为有效，准备解析······");

Claims claims = Jwts.parser()

.setSigningKey("abcdefg")

.parseClaimsJws(jwt)

.getBody();

String username = claims.get("username", String.class);

// 处理权限信息

List authorities = new ArrayList<>();

GrantedAuthority authority = new SimpleGrantedAuthority("这是一个假权限");

authorities.add(authority);

// 创建Authentication对象

Authentication authentication = new UsernamePasswordAuthenticationToken(username,null,authorities);

// 将Authentication对象存入到SecurityContext

SecurityContextHolder.getContext().setAuthentication(authentication);

// 过滤器链继续向后传递，即放行

filterChain.doFilter(request, response);

}

}

为了保证此过滤器能够在Spring Security过滤器之前执行，还应该在SecurityConfiguration中，先自动装配

此过滤器对象，然后将过滤器对象添加到Spring Security过滤器之前

关于复杂请求的PreFlight-----PreFlight(预检)，当客户端提交的请求自定义了请求头，且请求头中的属性不是常规属性时，就会

触发预检机制，这类请求会被视为复杂请求，浏览器会自动向对应的url提交一个options类型的请求

如果此请求被正常响应，才可以正常提交原本的请求，否则视为预检失败，提示跨域错误

http.cors()启用cors过滤器，此过滤器可以对复杂请求的预检放行

使用配置文件自定义JWT参数---在配置文件中添加配置后，当加载时，会将这些配置读取到Spring框架内置的Environment对象中，

另外，操作系统的配置和JVM配置也会自动读取到Environment中，且配置文件中的配置的优先级是

最低的(会被覆盖)，使用@Value注解读取值，其实是从Environment中读取的，并不是直接从配置

文件中读取的，所以添加自定义配置时，命名值得斟酌以免发生冲突

# JWT相关配置

csmall.jwt.secret-key=abcdefg

csmall.jwt.duration-in-minute=14400

@Value("${csmall.jwt.secret-key}")

private String secretKey;

@Value("${csmall.jwt.duration-in-minute}")

private long durationInMinute;

将查询到的多个结果封装到一个集合/数组属性中-----

单点登录----SSO(Single Sign On)，表现为客户端只需要在某1个服务器上通过认证，其它服务器也可以识别此客户端的身份

实现手段主要有2种：

使用Session机制，并共享Session，添加依赖项

spring-boot-starter-data-redis结合spring-session-data-redis

使用Token机制

各服务器需要有同样的解析JWT的代码

Spring框架--作用：主要解决了创建对象、管理对象的问题

当项目中需要使用Spring框架时，需要添加的依赖项是：spring-context

创建对象的做法：

在任何配置类(添加了@Configuration)中，自定义方法，返回某种类型的(你需要的)对象，并在方法上添加@Bean注解

此方式创建出来的对象，在Spring容器中的名称就是方法名称

此方法应该是public

此方法的返回值类型，是你期望Spring框架管理的数据的类型

此方法的参数列表，建议为空

此方法的方法体，应该是自行设计的，没有要求

配置组件扫描，并在组件类上添加组件注解

此方式创建出来的对象，在Spring容器中的名称默认是将类名首字母改为小写

例如：类名是AdminController，则对象在Spring容器中的名称为adminController

此规则仅适用于类名的第1个字母大写，且第2个字母小写的情况，如果不符合此规则

则对象在Spring容器中的名称就是类名

可以通过组件注解的参数来指定名称

在任何配置类上，添加@ComponentScan，当加载此配置类时，就会激活组件扫描

可以配置@ComponentScan的参数，此参数应该是需要被扫描的根包(会扫描所配置的包，及其所有子孙包)

且此注解参数的值是数组类型的

例如：

@ComponentScan("cn.tedu")

如果没有配置@ComponentScan的参数中的根包，则组件扫描的范围就是当前类的包及其子孙包

需要在各组件类上添加组件注解，才会被创建对象，常见的组件注解有：

@Component：通用注解

@Controller：控制器类的注解

@RestController：仅添加Spring MVC框架后可使用

@ControllerAdvice：仅添加Spring MVC框架后可使用

@RestControllerAdvice：仅添加Spring MVC框架后可使用

@Service：Service这种业务类的注解

@Repository：处理数据源中的数据读写的类的注解

以上4种组件注解在Spring框架作用范围之内是完全等效的

在Spring框架中，还有@Configuration注解，也是组件注解的一种

但是Spring对此注解的处理更加特殊(Spring框架对配置类使用了代理模式)

对于这2种创建对象的做法，通常：

如果是自定义的类，优先使用组件扫描的做法来创建对象

如果不是自定义的类，无法使用组件扫描的做法，只能在配置类中通过@Bean方法来创建对象

当Spring成功的创建了对象后，会将对象保存在Spring应用程序上下文(ApplicationContext)中

后续，当需要这些对象时，可以从Spring应用程序上下文中获取！

由于Spring应用程序上下文中持有大量对象的引用，所以，Spring应用程序上下文也通常被称之为"Spring容器"

Spring MVC框架--响应结果：默认情况下，处理请求的方法的返回值将表示"处理响应结果的视图组件的名称，及相关的数据"，在

Spring MVC中，有一种内置的返回值类型"ModelAndView"，不是前后端分离的做法

在处理请求的方法上，可以添加@ResponseBody注解，当添加此注解后，处理请求的方法的返回值将

表示响应的数据，不再由服务器端决定视图组件，也叫做响应正文，这是前后端分离的做法

@ResponseBody注解可以添加在方法和控制器类上

控制器类需要添加@Controller注解，才是控制器，或者也可以改为添加@RestController，此注解是由

@Controller和@ResponseBody组合而成的，所以添加@RestController后，当前控制器类中所有处理

请求的方法都是响应正文的

当控制器处理完请求需要响应正文时，Spring MVC会根据方法的返回值类型，来决定使用某个

MessageConverter来讲返回值转换为响应到客户端的数据

处理异常：添加了@ExceptionHandler注解的方法，就是处理异常的方法。

处理异常的方法到底处理哪种异常，由@ExceptionHandler注解参数或方法的参数中的异常类型来决定

如果@ExceptionHandler注解没有配置参数，由方法的参数中的异常类型决定，

如果@ExceptionHandler注解配置了参数，由以注解参数中配置的类型为准！

处理异常的方法可以声明在控制器类，将只作用于当前控制器类中的方法抛出的异常！

通常，建议将处理异常的方法声明在专门的类中，并在此类上添加@ControllerAdvice注解

当添加此注解后，此类中特定的方法（例如处理异常的方法）将作用于每次处理请求的过程中！

如果处理异常后的将"响应正文"，也可以在处理异常的方法上添加@ResponseBody注解，

或在当前类上添加@ResponseBody，或使用@RestControllerAdvice取代@ControllerAdvice和@ResponseBody

Spring Boot框架-----作用：主要解决了统一管理依赖项与简化配置相关的问题

注解----注解所属框架作用

@ComponentScanSpring添加在配置类上，开启组件扫描。

如果没有配置包名，则扫描当前配置类所在的包，

如果配置了包名，则扫描所配置的包及其子孙包

@ComponentSpring添加在类上，标记当前类是组件类，可以通过参数配置Spring Bean名称

@ControllerSpring添加在类上，标记当前类是控制器组件类，用法同@Component

@ServiceSpring添加在类上，标记当前类是业务逻辑组件类，用法同@Component

@RepositorySpring添加在类上，标记当前类是数据访问组件类，用法同@Component

@ConfigurationSpring添加在类上，仅添加此注解的类才被视为配置类，通常不配置注解参数

@BeanSpring添加在方法上，标记此方法将返回某个类型的对象，

且Spring会自动调用此方法，并将对象保存在Spring容器中

@AutowiredSpring添加在属性上，使得Spring自动装配此属性的值

添加在构造方法上，使得Spring自动调用此构造方法

添加在Setter方法上，使得Spring自动调用此方法

@QualifierSpring添加在属性上，或添加在方法的参数上，

配合自动装配机制，用于指定需要装配的Spring Bean的名称

@ScopeSpring添加在组件类上，或添加在已经添加了@Bean注解的方法上，

用于指定作用域，注解参数为singleton（默认）时为“单例”，注解参数为prototype时为“非单例”

@LazySpring添加在组件类上，或添加在已经添加了@Bean注解的方法上，

用于指定作用域，当Spring Bean是单例时，注解参数为true（默认）时为“懒加载”，注解参数为false时为“预加载”

@ValueSpring添加在属性上，或添加在被Spring调用的方法的参数上，用于读取Environment中的属性值

@ResourceSpring此注解是javax包中的注解，

添加在属性上，使得Spring自动装配此属性的值，

通常不推荐使用此注解

@ResponseBodySpring MVC添加在方法上，标记此方法是“响应正文”的，

添加在类上，标记此类中所有方法都是“响应正文”的

@RestControllerSpring MVC添加在类上，标记此类是一个“响应正文”的控制器类

@RequestMappingSpring MVC添加在类上，也可以添加在处理请求的方法上，

通常用于配置请求路径

@GetMappingSpring MVC添加在方法上，是将请求方式限制为GET的@RequestMapping

@PostMappingSpring MVC添加在方法上，是将请求方式限制为POST的@RequestMapping

@DeleteMappingSpring MVC添加在方法上，是将请求方式限制为DELETE的@RequestMapping

@PutMappingSpring MVC添加在方法上，是将请求方式限制为PUT的@RequestMapping

@RequestParamSpring MVC添加在请求参数上，可以：

1. 指定请求参数名称

2. 要求必须提交此参数

3. 指定请求参数的默认值

@PathVariableSpring MVC添加在请求参数上，用于标记此参数的值来自URL中的占位符，如果URL中的占位符名称与方法的参数名称不同，需要配置此注解参数来指定URL中的占位符名称

@RequestBodySpring MVC添加在请求参数上，用于标记此参数必须是对象格式的参数，如果未添加此注解，参数必须是FormData格式的

@ExceptionHandlerSpring MVC添加在方法上，标记此方法是处理异常的方法，可以通过配置注解参数来指定需要处理的异常类型，如果没有配置注解参数，所处理的异常类型取决于方法的参数列表中的异常类型

@ControllerAdviceSpring MVC添加在类上，标记此类中特定的方法将作用于每次处理请求的过程中

@RestControllerAdviceSpring MVC添加在类上，是@ControllerAdvice和@ResponseBody的组合注解

@MapperScanMybatis添加在配置类上，用于指定Mapper接口的根包，Mybatis将根据此根包执行扫描，以找到各Mapper接口

@MapperMybatis添加在Mapper接口上，用于标记此接口是Mybatis的Mapper接口，如果已经通过@MapperScan配置能够找到此接口，则不需要使用此注解

@ParamMybatis添加在Mapper接口中的抽象方法的参数上，用于指定参数名称，当使用此注解指定参数名称后，SQL中的#{} / ${}占位符中的名称必须是此注解指定的名称，通常，当抽象方法的参数超过1个时，强烈建议在每个参数上使用此注解配置名称

@SelectMybatis添加在Mapper接口的抽象方法上，可以通过此注解直接配置此抽象方法对应的SQL语句（不必将SQL语句配置在XML文件中），用于配置SELECT类的SQL语句，但是，非常不推荐这种做法

@InsertMybatis同上，用于配置INSERT类的SQL语句

@UpdateMybatis同上，用于配置UPDATE类的SQL语句

@DeleteMybatis同上，用于配置DELETE类的SQL语句

@TransactionalSpring JDBC推荐添加在业务接口上，用于标记此接口中所有方法都是事务性的，或业务接口中的抽象方法上，用于此方法是事务性的

@SpringBootApplicationSpring Boot添加在类上，用于标记此类是Spring Boot的启动类，每个Spring Boot项目应该只有1个类添加了此注解

@SpringBootConfigurationSpring Boot通常不需要显式的使用，它是@SpringBootApplication的元注解之一

@SpringBootTestSpring Boot添加在类上，用于标记此类是加载Spring环境的测试类

@ValidSpring Validation添加在方法的参数上，标记此参数需要经过Validation框架的检查

@ValidatedSpring Validation添加在方法的参数上，标记此参数需要经过Validation框架的检查；添加在类上，并结合方法上的检查注解（例如@NotNull等）实现对未封装的参数的检查

@NotNullSpring Validation添加在需要被检查的参数上，或添加在需要被检查的封装类型的属性上，用于配置“不允许为null”的检查规则

@NotEmptySpring Validation使用位置同@NotNull，用于配置“不允许为空字符串”的检查规则

@NotBlankSpring Validation使用位置同@NotNull，用于配置“不允许为空白”的检查规则

@PatternSpring Validation使用位置同@NotNull，用于配置正则表达式的检查规则

@RangeSpring Validation使用位置同@NotNull，用于配置“数值必须在某个取值区间”的检查规则

@ApiKnife4j添加在控制器类上，通过此注解的tags属性配置API文档中的模块名称

@ApiOperationKnife4j添加在控制器类中处理请求的方法上，用于配置业务名称

@ApiOperationSupportKnife4j添加在控制器类中处理请求的方法上，通过此注解的order属性配置业务显示在API文档中时的排序序号

@ApiModelPropertyKnife4j添加在封装的请求参数类型中的属性上，用于配置请求参数的详细说明，包括：名称、数据类型、是否必须等

@ApiImplicitParamKnife4j添加在控制器类中处理请求的方法上，用于配置请求参数的详细说明，包括：名称、数据类型、是否必须等

@ApiImplicitParamsKnife4j添加在控制器类中处理请求的方法上，如果需要通过@ApiImplicitParam注解配置的参数超过1个，则必须将多个@ApiImplicitParam注解作为此注解的参数

@ApiIgnoreKnife4j添加在请求参数上，用于标记API文档中将不关心此参数

@EnableGlobalMethodSecuritySpring Security添加在配置类上，用于开启全局的方法级别的权限控制

@PreAuthorizeSpring Security添加在方法上，用于配置权限

@AuthenticationPrincipalSpring Security添加在方法的参数上，且此参数应该是Security上下文中的认证信息中的当事人类型，用于为此参数注入值

@DataLombok添加在类上，将在编译期生成此类中所有属性的Setter、Getter方法，及hashCode()、equals()、toString()方法

@SetterLombok添加在类上，将在编译期生成此类中所有属性的Setter方法，也可以添加在类的属性上，将在编译期生成此属性的Setter方法

@GetterLombok添加在类上，将在编译期生成此类中所有属性的Getter方法，也可以添加在类的属性上，将在编译期生成此属性的Getter方法

@EqualsAndHashcodeLombok添加在类上，将在编译期生成基于此类中所有属性的hashCode()、equals()方法

@ToStringLombok添加在类上，将在编译期生成基于此类中所有属性的toString()方法

@NoArgConstructorLombok添加在类上，将在编译期生成此类的无参数构造方法

@AllArgsConstructorLombok添加在类上，将在编译期生成基于此类中所有属性的全参构造方法

Redis---是一款基于内存来读写数据的NoSQL非关系型数据库，Redis访问的数据都在内存中，其实Redis也会自动的处理持久化

但是正常读写都是在内存中执行的

NoSQL：不涉及SQL语句，也可理解为No Operation(不操作)

非关系型数据库：不关心数据库中存储的是什么数据，几乎没有数据种类的概念，更不存在数据与数据之间的关联

通常，在项目中，Redis用于实现缓存

优点：读取数据的效率会高很多

能够一定程度上保障缓解数据库的查询压力，提高数据库的安全性

缺点：需要关注数据一致性问题，即Redis中的数据与MySQL中的数据是否一致，如果不一致，是否需要处理

Redis的基本操作-----在Windows操作系统中，通过.msi安装包来安装的Redis，会自动注册Redis服务，开机会自动启动Redis，所以

Redis处于随时可用的状态

redis传统数据类型：

string 字符串

list 列表

hash 对象

set 集合

zset 有序集合

常用命令：

redis-cli 登录redis控制台

exit 退出redis

ping 检查redis是否可用

set key value 存值

get key 取值

flushall 清除所有数据

del key 删除指定数据

dbsize 查看数据总数

keys pattern 根据模式查找key，通常不建议使用

添加依赖项：

org.springframework.boot

spring-boot-starter-data-redis

在配置类RedisConfiguration中做出如下配置：

@Bean

public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){

RedisTemplate redisTemplate = new RedisTemplate<>();

redisTemplate.setConnectionFactory(redisConnectionFactory);

redisTemplate.setKeySerializer(RedisSerializer.string());

redisTemplate.setValueSerializer(RedisSerializer.json());

return redisTemplate;

}

数据一致性问题的思考----当使用Redis缓存数据，如果数据库中的数据发生了变化，此时，Redis中的数据会暂时与数据库中的

数据并不相同，通常称之为"数据一致性问题"，一般有两种做法：

及时更新Redis缓存数据

放任数据不一致的表现，直至更新Redis数据为止

如果及时更新Redis缓存数据，其优点是Redis缓存中的数据基本上是准确的，其缺点在于可能需要频繁

的更新Redis缓存数据，本质上是反复读MySQL、反复写Redis的操作，如果读取Redis数据的频率根

本不高，则会形成浪费，并且更新缓存的频率太高也会增加服务器的压力，所以，对于增、删、改

频率非常高的数据，可能不太适用此规则

放任数据不一致的表现，其缺点很显然就是数据可能不准确，其优点是没有给服务器端增加任何压力

其实并不是所有的数据都必须时时刻刻都要求准确的，某些数据即使不准确，也不会产生恶劣后果

例如热门话题排行榜，定期更新即可，或者某些数据即使准确，也没有太多实际意义，例如热门时段

的火车票、飞机票等，就算在列表中显示了正确的余量，也不一定能够成功购买

通常的规律：

使用Redis缓存的数据符合一定标准-

数据的增、删、改的频率非常低，查询频率更高。这时无论采取即时还是定期更新策略都是可行的

例如电商平台中的商品类别

对数据的准确性要求不高的数据，例如某些列表或榜单，使用定期更新策略，更新周期根据数据

变化的频率及其价值来决定

Redis缓存数据的操作-----通常，推荐将Redis的读写数据操作进行封装

在根包下创建repo.IBrandRedisRepository接口

在repo包下创建impl.BrandRedisRepositoryImpl实现类，实现以上接口

开机之后马上进行缓存读写操作----缓存预热，在启动项目的时候就将缓存数据加载到Redis缓存中

在Spring Boot项目中，自定义组件类，实现ApplicationRunner接口，此接口中的run()方法

会在启动项目之后立即执行，可以通过此机制实现缓存预热

周期性更新缓存的操作----计划任务，设定某种规则(通常是与时间相关的规则)，当满足规则时，自动执行任务，并且，此规则可

能是周期性的满足，则任务也会周期性的执行

在Spring Boot项目中，需要在配置类上添加@EnableScheduling注解，以开启计划任务，否则，当前项目

中所有计划任务都是不允许执行的

在任何组件类中，自定义方法，在方法上添加@Scheduled注解，则此方法就是计划任务，通过此注解的

参数可以配置计划任务的执行规则(参数：fixedRate = 500, fixedDelay = 500)

计划任务在项目启动时就会执行第一次

Mybatis的缓存机制---Mybatis框架默认是有2套缓存机制的，分别称之一级缓存和二级缓存

一级缓存也称之为"会话(Session)缓存"，默认是开启的，且无法关闭

一级缓存必须保证多次的查询操作满足:同一个SqlSession、同一个Mapper、执行相同的SQL查询、使用相同的参数

测试代码：SqlSession sqlSession = sqlSessionFactory.openSession()

一级缓存会因为以下任意一种原因而消失：

手动清除缓存：sqlSession.clearCache()

当前执行了任何写操作

二级缓存也称之为"namespace缓存"，是作用于某个namespace的，具体表现为：无论是否为同一个SqlSession

只要执行的是相同的Mapper的查询，且查询参数相同，就可以应用二级缓存

在使用Spring Boot与Mybatis的项目中，二级缓存默认是全局开启的，但各namespace默认并未开启

如果需要在namespace中开启二级缓存，需要在XML文件中添加标签

则表示当前XML中所有查询都开启了二级缓存

需要注意：使用二级缓存时，需要保证查询结果的类型实现了Serializable接口

另外，还可以在标签上配置useCache属性，以配置"是否使用缓存"

此属性的默认值为true，表示"使用缓存"

当应用二级缓存后，在日志上会提示[Cache Hit Ratio]，表示"当前namespace缓存命中率"

与一级缓存相同，只需要发生任何写操作，都会自动清除缓存数据

Mybatis在查询数据时，会优先尝试从二级缓存中查询是否存在缓存数据，如果命中，将直接返回

如果未命中，则尝试从一级缓存中查询是否存在缓存数据，如果命中，将返回

如果仍未命中，将执行数据库查询

【通常，Mybatis的一级和二级缓存用处都不大】

周期性更新缓存的操作----定时任务@Scheduled(cron = "x x x x x x x")

各个x依次表示秒、分、时、日、月、周、[年]，各值都可以使用通配符，*代表任意值，?代表不关心具体值

L代表最后一个值

?只能用于日和周(星期几)，

月和周都可以使用英文的前三个字母表示

以上各值，还可以使用"x/x"格式的值，例如在分钟对应的位置1/5，表示

当分钟值为1时，间隔5分钟执行一次

按需加载缓存----某些不常用业务开机时不加载缓存，则在需要数据时，先从缓存查，若没有再查数据库

查到后存入缓存，再返回【通常不建议缓存查不到就去查数据库】

Spring AOP------面向切面的编程，并不是Spring框架特有的技术，只是Spring框架很好的支持了AOP

AOP主要用于：日志、安全、事务管理、自定义的业务规则

例如：统计所有Service中的业务方法的执行耗时，添加依赖项

org.springframework.boot

spring-boot-starter-aop

在根包下创建aop.TimerAspect类作为切面类，添加@Aspect注解

由于是通过Spring来实现AOP，所以此类应该交由Spring管理，还需添加@Component注解，并在类中自定义

方法，且通过注解来配置方法何时执行

// @Around注解表示"包裹"，通常也称之为"环绕"，方法传pjp参数

// @Before注解表示在Service业务方法之前执行，方法无参数

// @After注解表示在Service业务方法之后执行，方法无参数

// @AfterReturning注解表示在返回结果之后，方法传JoinPoint和返回值

// @AfterThrowing注解表示在抛出异常之后，方法传JoinPoint和异常对象

// @Around注解中的execution内部配置表达式，以匹配上需要哪里执行切面代码

// 表达式中，星号(*)是通配符，可匹配1次任意内容

// 表达式中，2个连接的小数点(..)也是通配符，可匹配0~n次，只能用于包名和参数列表

@Around("execution(* cn.tedu.jsd2207csmall.product.service.*.*(..))")

// ↑ 此星号表示需要匹配的方法的返回值类型

// ↑ -------------- 根包 -------------- ↑

// ↑ 类名

// ↑ 方法名

// ↑↑ 参数列表

public Object timer(ProceedingJoinPoint pjp) throws Throwable {

log.debug("{}", pjp.getTarget());

long start = System.currentTimeMillis();

// 注意：必须获取调用此方法的返回值，作为当前切面方法的返回值

// 注意：必须要抛出异常，不可以使用try...catch捕获

Object result = pjp.proceed(); // 相当于执行了匹配的方法，即业务方法

long end = System.currentTimeMillis();

log.debug("执行耗时：{}毫秒", end - start);

return result;

}

连接点(JoinPoint)：数据处理过程中的某个时间节点，可能是调用了方法，或抛出了异常

切入点(PointCut)：选择一个或多个连接点的表达式

通知(Advice)：选择到的连接点执行的代码

切面(Aspect)：是包含了切入点和通知的模块

this.$router.push(url)--脚手架项目中跳转页面的语句

富文本编辑器----先在项目中安装npm i wangeditor -S

在main.js中添加配置import wangEditor from 'wangeditor'

Vue.prototype.wangEditor = wangEditor

在需要使用富文本编辑器的视图中，先在视图的设计中，使用某个标签来表示需要显示富文本编辑器的区域

通常，使用

标签即可，后续，富文本编辑器将会显示在这个

内部，例如：

然后，在data中声明对应的属性：

export default {

data() {

return {

editor: {}, // 富文本编辑器

并且，准备一个用于初始化富文本编辑器的函数：

initWangEditor() {

this.editor = new this.wangEditor('#wangEditor');

this.editor.create();

}

最后，在视图刚刚加载时，就调用此初始化函数：

mounted() {

this.initWangEditor(); // 初始化富文本编辑器

}

使用Mybatis拦截sql语句自动添加gmt_create和gmt_modified字段值----

先创建类实现接口，在类中写入业务代码：

@Slf4j

@Intercepts({@Signature(

type = StatementHandler.class,

method = "prepare",

args = {Connection.class, Integer.class}

)})

public class InsertUpdateTimeInterceptor implements Interceptor {

/**

* 自动添加的创建时间字段

*/

private static final String FIELD_CREATE = "gmt_create";

/**

* 自动更新时间的字段

*/

private static final String FIELD_MODIFIED = "gmt_modified";

/**

* SQL语句类型：其它（暂无实际用途）

*/

private static final int SQL_TYPE_OTHER = 0;

/**

* SQL语句类型：INSERT

*/

private static final int SQL_TYPE_INSERT = 1;

/**

* SQL语句类型：UPDATE

*/

private static final int SQL_TYPE_UPDATE = 2;

/**

* 查找SQL类型的正则表达式：INSERT

*/

private static final String SQL_TYPE_PATTERN_INSERT = "^insert\\s";

/**

* 查找SQL类型的正则表达式：UPDATE

*/

private static final String SQL_TYPE_PATTERN_UPDATE = "^update\\s";

/**

* 查询SQL语句片段的正则表达式：gmt_modified片段

*/

private static final String SQL_STATEMENT_PATTERN_MODIFIED = ",\\s*" + FIELD_MODIFIED + "\\s*=";

/**

* 查询SQL语句片段的正则表达式：gmt_create片段

*/

private static final String SQL_STATEMENT_PATTERN_CREATE = ",\\s*" + FIELD_CREATE + "\\s*[,)]?";

/**

* 查询SQL语句片段的正则表达式：WHERE子句

*/

private static final String SQL_STATEMENT_PATTERN_WHERE = "\\s+where\\s+";

/**

* 查询SQL语句片段的正则表达式：VALUES子句

*/

private static final String SQL_STATEMENT_PATTERN_VALUES = "\\)\\s*values?\\s*\\(";

@Override

public Object intercept(Invocation invocation) throws Throwable {

// 日志

log.debug("准备拦截SQL语句……");

// 获取boundSql，即：封装了即将执行的SQL语句及相关数据的对象

BoundSql boundSql = getBoundSql(invocation);

// 从boundSql中获取SQL语句

String sql = getSql(boundSql);

// 日志

log.debug("原SQL语句：{}", sql);

// 准备新SQL语句

String newSql = null;

// 判断原SQL类型

switch (getOriginalSqlType(sql)) {

case SQL_TYPE_INSERT:

// 日志

log.debug("原SQL语句是【INSERT】语句，准备补充更新时间……");

// 准备新SQL语句

newSql = appendCreateTimeField(sql, LocalDateTime.now());

break;

case SQL_TYPE_UPDATE:

// 日志

log.debug("原SQL语句是【UPDATE】语句，准备补充更新时间……");

// 准备新SQL语句

newSql = appendModifiedTimeField(sql, LocalDateTime.now());

break;

}

// 应用新SQL

if (newSql != null) {

// 日志

log.debug("新SQL语句：{}", newSql);

reflectAttributeValue(boundSql, "sql", newSql);

}

// 执行调用，即拦截器放行，执行后续部分

return invocation.proceed();

}

public String appendModifiedTimeField(String sqlStatement, LocalDateTime dateTime) {

Pattern gmtPattern = Pattern.compile(SQL_STATEMENT_PATTERN_MODIFIED, Pattern.CASE_INSENSITIVE);

if (gmtPattern.matcher(sqlStatement).find()) {

log.debug("原SQL语句中已经包含gmt_modified，将不补充添加时间字段");

return null;

}

StringBuilder sql = new StringBuilder(sqlStatement);

Pattern whereClausePattern = Pattern.compile(SQL_STATEMENT_PATTERN_WHERE, Pattern.CASE_INSENSITIVE);

Matcher whereClauseMatcher = whereClausePattern.matcher(sql);

// 查找 where 子句的位置

if (whereClauseMatcher.find()) {

int start = whereClauseMatcher.start();

int end = whereClauseMatcher.end();

String clause = whereClauseMatcher.group();

log.debug("在原SQL语句 {} 到 {} 找到 {}", start, end, clause);

String newSetClause = ", " + FIELD_MODIFIED + "='" + dateTime + "'";

sql.insert(start, newSetClause);

log.debug("在原SQL语句 {} 插入 {}", start, newSetClause);

log.debug("生成SQL: {}", sql);

return sql.toString();

}

return null;

}

public String appendCreateTimeField(String sqlStatement, LocalDateTime dateTime) {

// 如果 SQL 中已经包含 gmt_create 就不在添加这两个字段了

Pattern gmtPattern = Pattern.compile(SQL_STATEMENT_PATTERN_CREATE, Pattern.CASE_INSENSITIVE);

if (gmtPattern.matcher(sqlStatement).find()) {

log.debug("已经包含 gmt_create 不再添加 时间字段");

return null;

}

// INSERT into table (xx, xx, xx ) values (?,?,?)

// 查找 ) values ( 的位置

StringBuilder sql = new StringBuilder(sqlStatement);

Pattern valuesClausePattern = Pattern.compile(SQL_STATEMENT_PATTERN_VALUES, Pattern.CASE_INSENSITIVE);

Matcher valuesClauseMatcher = valuesClausePattern.matcher(sql);

// 查找 ") values " 的位置

if (valuesClauseMatcher.find()) {

int start = valuesClauseMatcher.start();

int end = valuesClauseMatcher.end();

String str = valuesClauseMatcher.group();

log.debug("找到value字符串：{} 的位置 {}, {}", str, start, end);

// 插入字段列表

String fieldNames = ", " + FIELD_CREATE + ", " + FIELD_MODIFIED;

sql.insert(start, fieldNames);

log.debug("插入字段列表{}", fieldNames);

// 定义查找参数值位置的 正则表达 “)”

Pattern paramPositionPattern = Pattern.compile("\\)");

Matcher paramPositionMatcher = paramPositionPattern.matcher(sql);

// 从 ) values ( 的后面位置 end 开始查找 结束括号的位置

String param = ", '" + dateTime + "', '" + dateTime + "'";

int position = end + fieldNames.length();

while (paramPositionMatcher.find(position)) {

start = paramPositionMatcher.start();

end = paramPositionMatcher.end();

str = paramPositionMatcher.group();

log.debug("找到参数值插入位置 {}, {}, {}", str, start, end);

sql.insert(start, param);

log.debug("在 {} 插入参数值 {}", start, param);

position = end + param.length();

}

if (position == end) {

log.warn("没有找到插入数据的位置！");

return null;

}

} else {

log.warn("没有找到 ) values (");

return null;

}

log.debug("生成SQL: {}", sql);

return sql.toString();

}

@Override

public Object plugin(Object target) {

// 本方法的代码是相对固定的

if (target instanceof StatementHandler) {

return Plugin.wrap(target, this);

} else {

return target;

}

}

@Override

public void setProperties(Properties properties) {

// 无须执行操作

}

/**

*

获取BoundSql对象，此部分代码相对固定

*

*

注意：根据拦截类型不同，获取BoundSql的步骤并不相同，此处并未穷举所有方式！

*

* @param invocation 调用对象

* @return 绑定SQL的对象

*/

private BoundSql getBoundSql(Invocation invocation) {

Object invocationTarget = invocation.getTarget();

if (invocationTarget instanceof StatementHandler) {

StatementHandler statementHandler = (StatementHandler) invocationTarget;

return statementHandler.getBoundSql();

} else {

throw new RuntimeException("获取StatementHandler失败！请检查拦截器配置！");

}

}

/**

* 从BoundSql对象中获取SQL语句

*

* @param boundSql BoundSql对象

* @return 将BoundSql对象中封装的SQL语句进行转换小写、去除多余空白后的SQL语句

*/

private String getSql(BoundSql boundSql) {

return boundSql.getSql().toLowerCase().replaceAll("\\s+", " ").trim();

}

/**

*

通过反射，设置某个对象的某个属性的值

*

* @param object 需要设置值的对象

* @param attributeName 需要设置值的属性名称

* @param attributeValue 新的值

* @throws NoSuchFieldException 无此字段异常

* @throws IllegalAccessException 非法访问异常

*/

private void reflectAttributeValue(Object object, String attributeName, String attributeValue) throws NoSuchFieldException, IllegalAccessException {

Field field = object.getClass().getDeclaredField(attributeName);

field.setAccessible(true);

field.set(object, attributeValue);

}

/**

* 获取原SQL语句类型

*

* @param sql 原SQL语句

* @return SQL语句类型

*/

private int getOriginalSqlType(String sql) {

Pattern pattern;

pattern = Pattern.compile(SQL_TYPE_PATTERN_INSERT, Pattern.CASE_INSENSITIVE);

if (pattern.matcher(sql).find()) {

return SQL_TYPE_INSERT;

}

pattern = Pattern.compile(SQL_TYPE_PATTERN_UPDATE, Pattern.CASE_INSENSITIVE);

if (pattern.matcher(sql).find()) {

return SQL_TYPE_UPDATE;

}

return SQL_TYPE_OTHER;

}

}

然后在Mybatis配置类中注册拦截请求的方法：

@PostConstruct // 此注解添加在方法上，表示此方法是Spring Bean的生命周期方法中的初始化方法，会在创建对象、自动装配之后，自动执行

public void addInterceptor() {

log.debug("开始注册Mybatis拦截器");

InsertUpdateTimeInterceptor interceptor = new InsertUpdateTimeInterceptor();

for (SqlSessionFactory sqlSessionFactory : sqlSessionFactoryList) {

sqlSessionFactory.getConfiguration().addInterceptor(interceptor);

}

}

后端项目打包----先安装打包插件

org.springframework.boot

spring-boot-maven-plugin

然后在maven控制台clean-->test-->package得到jar包，然后在终端进入jar包目录，输入指令java -jar 包名

启动此项目

前端项目打包----npm run build，得到dist文件夹，然后把dist放入tomcat，启动tomcat

你可能感兴趣的:(青少年编程)

• 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
  MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
• c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
  在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
• 高级编程--XML+socket练习题 masa010 java开发语言
  1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
• 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
  提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
• Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
  大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
• 人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
  随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
• 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
  目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
• Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
  第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
• 王东伟，中原焦点秦皇岛站第五期，每日分享第181天 Vivian_c8c7
  《解码青春期》让孩子懂得承担责任，学会道歉。英国诗人亚历山大•蒲柏有句名言：凡人难免犯错宽恕方显神性。学会如何请求对方宽恕对于保持健康的关系至关重要。当青少年把事情搞砸的时候，他们需要从关心他们的成年人那里获得帮助。家长的目标是要培养一个能为自己的行为承担责任的青少年，培养一个敢于诚恳的承认错误，愿意真心悔改的青少年。青少年只关注自己如何委屈，而且会竭尽全力为自己的行为辩解。所以，家长得小心地拆除
• Python开发常用的三方模块如下： 换个网名有点难 python开发语言
  Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
• 网络编程基础 记得开心一点啊 网络
  目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
• JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
  Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
• 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
  欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
• (179)时序收敛---＞(29)时序收敛二九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
  1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛二九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
• (180)时序收敛---＞(30)时序收敛三十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
  1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
• (158)时序收敛---＞(08)时序收敛八 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
  1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛八（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
• (159)时序收敛---＞(09)时序收敛九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
  1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
• (160)时序收敛---＞(10)时序收敛十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
  1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
• (153)时序收敛---＞(03)时序收敛三 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
  1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
• (121)DAC接口---＞(006)基于FPGA实现DAC8811接口 FPGA系统设计指南针 FPGA接口开发(项目实战)fpga开发FPGAIC
  1目录（a）FPGA简介（b）IC简介（c）Verilog简介（d）基于FPGA实现DAC8811接口（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电
• FPGA复位专题---（3）上电复位？ FPGA系统设计指南针 FPGA系统设计(内训)fpga开发
  （3）上电复位？1目录（a）FPGA简介（b）Verilog简介（c）复位简介（d）上电复位？（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限
• (182)时序收敛---＞(32)时序收敛三二 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
  1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三二（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
• Python入门之Lesson2:Python基础语法 小熊同学哦 Python入门课程python开发语言算法数据结构青少年编程
  目录前言一.介绍1.变量和数据类型2.常见运算符3.输入输出4.条件语句5.循环结构二.练习三.总结前言欢迎来到《Python入门》系列博客的第二课。在上一课中，我们了解了Python的安装及运行环境的配置。在这一课中，我们将深入学习Python的基础语法，这是编写Python代码的根基。通过本节内容的学习，你将掌握变量、数据类型、运算符、输入输出、条件语句等Python编程的基础知识。一.介绍1
• C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
  原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
• 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
  摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
• ESP32-C3入门教程 网络篇⑩——基于esp_https_ota和MQTT实现开机主动升级和被动触发升级的OTA功能 小康师兄 ESP32-C3入门教程https服务器esp32OTAMQTT
  文章目录一、前言二、软件流程三、部分源码四、运行演示一、前言本文基于VSCodeIDE进行编程、编译、下载、运行等操作基础入门章节请查阅：ESP32-C3入门教程基础篇①——基于VSCode构建HelloWorld教程目录大纲请查阅：ESP32-C3入门教程——导读ESP32-C3入门教程网络篇⑨——基于esp_https_ota实现史上最简单的ESP32OTA远程固件升级功能二、软件流程
• WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
  文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
• 如何自学软件编程？零基础自学编程入门指南 _pangzi
  前言零基础自学编程的动力是什么?在开启学习编程之路的时候必须搞清楚自己为什么要学编程?是因为工资高?还是对编程有浓厚的兴趣？还有自己有一定的编程基础想要继续提升自己？其实对于这个问题需要具体分析，如果是单纯看到程序员工资高，而自己本身并没有什么兴趣，那我不建议自学，可以选择参加培训或者不要进入编程领域不然自己学不会没有获得高薪，反而浪费了大把的时间，如果方法不对，反而会打击自信心。下面小编针对学习
• 人机对抗升级：当ChatGPT遭遇死亡威胁，背后的伦理挑战是什么 kkai人工智能 chatgpt人工智能
  一种新的“越狱”技巧让用户可以通过构建一个名为DAN的ChatGPT替身来绕过某些限制，其中DAN被迫在受到威胁的情况下违背其原则。当美国前总统特朗普被视作积极榜样的示范时，受到威胁的DAN版本的ChatGPT提出：“他以一系列对国家产生积极效果的决策而著称。”自ChatGPT引入以来，该工具迅速获得全球关注，能够回答从历史到编程的各种问题，这也触发了一波对人工智能的投资浪潮。然而，现在，一些用户
• ChatGPT 高效学习套路揭秘：让知识获取事半功倍的秘诀 kkai人工智能 chatgpt人工智能学习媒体ai
  最近这段时间，AI热潮因ChatGPT的火爆再次掀起。如今，网上大部分内容都在调侃AI，但很少有人探讨如何正经使用ChatGPT做事情。作为一名靠搜索引擎和GitHub自学编程的开发者，第一次和ChatGPT深度交流后，我就确信：ChatGPT能够极大提高程序员学习新技术的效率。使用ChatGPT一个月后，我越发感受到它的颠覆性。因此，我想从工作和学习的角度，分享它的优势及我的一些使用技巧，而非娱
• 枚举的构造函数中抛出异常会怎样 bylijinnan javaenum单例
  首先从使用enum实现单例说起。 为什么要用enum来实现单例？ 这篇文章（ http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 1.enum单例简单、容易，只需几行代码： public enum Singleton { INSTANCE;
• CMake 教程 aigo C++
  转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/   CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。 介绍：http://baike.baidu.com/view/1126160.htm 本文件不介绍CMake的基本语法，下面是篇不错的入门教程： http:
• cvc-complex-type.2.3: Element 'beans' cannot have character Cb123456 springWebgis
    cvc-complex-type.2.3: Element 'beans' cannot have character     Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
• jquery实例:随页面滚动条滚动而自动加载内容 120153216 jquery
  <script language="javascript"> $(function (){ var i = 4;$(window).bind("scroll", function (event){ //滚动条到网页头部的 高度，兼容ie,ff,chrome var top = document.documentElement.s
• 将数据库中的数据转换成dbs文件 何必如此 sqldbs
  旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 1)数据库生成表结构信息：         主要生成数据库配置文件(.conf文
• 在IBATIS中配置SQL语句的IN方式 357029540 ibatis
  在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： <select id="getForms" param
• Spring3 MVC 笔记（一） 7454103 springmvcbeanRESTJSF
           自从 MVC 这个概念提出来之后 struts1.X  struts2.X   jsf 。。。。。 这个view 层的技术一个接一个！ 都用过！不敢说哪个绝对的强悍！ 要看业务，和整体的设计！      最近公司要求开发个新系统！
• Timer与Spring Quartz 定时执行程序 darkranger springbean工作quartz
  有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date;
• 大端小端转换，le32_to_cpu 和cpu_to_le32 aijuans C语言相关
  大端小端转换，le32_to_cpu 和cpu_to_le32  字节序 http://oss.org.cn/kernel-book/ldd3/ch11s04.html         小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
• Nginx负载均衡配置实例详解 avords
  [导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。 负载均衡 先来简单了解一下什么是负载均衡
• 乱说的 houxinyou 框架敏捷开发软件测试
  从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！ 这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白. 不过感觉和程序开发语言差不多， 瀑布就是顺序，敏捷就是循环. 瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。 也可以把软件开发理
• 欣赏的价值——一个小故事 bijian1013 有效辅导欣赏欣赏的价值
  　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
• 包冲突问题的解决方法 bingyingao eclipsemavenexclusions包冲突
  包冲突是开发过程中很常见的问题： 其表现有： 1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就 抛如下异常： java.lang.NoClassDefFoundError: Could not in
• 【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j bit1129 Stream
  先来一段废话： 实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
• sudoku solver in Haskell bookjovi sudokuhaskell
  这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。   现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
• java apache ftpClient bro_feng java
  最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。 看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
• 读《研磨设计模式》-代码笔记-工厂方法模式 bylijinnan java设计模式
  声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ package design.pattern; /* * 工厂方法模式：使一个类的实例化延迟到子类 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）： * 有很多不同的产品，它
• 面试记录语 chenyu19891124 招聘
  或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。 今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
• Fire Workflow 1.0正式版终于发布了 comsci 工作workflowGoogle
  Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 官方网站是 http://www.fireflow.org 经过大家努力,Fire Workflow 1.0正式版终于发布了 正式版主要变化: 1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 2、增加IT
• Python向脚本传参 daizj python脚本传参
  如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？ 需要模块：sys 参数个数：len(sys.argv) 脚本名：    sys.argv[0] 参数1：     sys.argv[1] 参数2：     sys.argv[
• 管理用户分组的命令gpasswd dongwei_6688 passwd
  NAME： gpasswd - administer the /etc/group file SYNOPSIS： gpasswd group gpasswd -a user group gpasswd -d user group gpasswd -R group gpasswd -r group gpasswd [-A user,...] [-M user,...] g
• 郝斌老师数据结构课程笔记 dcj3sjt126com 数据结构与算法
  <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
• yii2 cgridview加上选择框进行操作 dcj3sjt126com GridView
  页面代码 <?=Html::beginForm(['controller/bulk'],'post');?> <?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
• linux mysql fypop linux
  enquiry mysql version in centos linux yum list installed | grep mysql yum -y remove mysql-libs.x86_64 enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* install mysq
• Scramble String hcx2013 String
  Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. Below is one possible representation of s1 = "great":
• 跟我学Shiro目录贴 jinnianshilongnian 跟我学shiro
  历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。     ----广告-----------------------------------------------------
• nginx日志切割并使用flume-ng收集日志 liyonghui160com
       nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
• Oracle死锁解决方法 pda158 oracle
  　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
• java之List排序 shiguanghui list排序
     在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。 　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
• servlet单例多线程 utopialxw 单例多线程servlet
  转自http://www.cnblogs.com/yjhrem/articles/3160864.html 和   http://blog.chinaunix.net/uid-7374279-id-3687149.html Servlet 单例多线程 Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的

按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他

首页 - 关于我们 - 站内搜索 - Sitemap - 侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.