Spring知识总结

Spring知识总结
目录

知识复习

一.spring

1.概念

2.常用注解

3.@componentsacn

4.aop

二.mybatis-plus

概念：

1.常见配置yaml

2.设置雪花主键

3.分页配置

4.代码生成器

5.公共字段自动填充

6.Lambda查询

三.Mybatis

概念：

1.xmlMapper文件

2.动态sql

3.自定义返回类型

4.mybatis-config.xml核心配置文件

5.单独使用的示例

6.在spring中的使用

8.事务的使用

9.整合druid连接池

10.整合druid在配置类中配置

四.springmvc

概念：

1.springmvc的在javaweb中的单独使用

2.springmvc在spring中的使用

3.springmvc的参数日期格式转换

4.全局日期参数自动转换

5.拦截器

6.拦截器的路径配置

7.拦截器和过滤器的区别

8.跨域配置

9.放行静态资源

五.springboot

概念：

1.springboot的搭建

2.springboot中开发web项目的依赖

（1）.引入springmvc依赖

（2）.引入mysql连接依赖**

（3）引入druid启动依赖

（4）.引入mybatis-plus依赖**

（5）.引入lombok依赖

3.对以上依赖的相关配置

(1)对端口配置

(2).对mysql和druid连接池配置

(3)对mybatis-plus的配置

4.springboot的简单示例

5.分页查询示例

6.LambdQueryWrapper

7.springboot中配置跨域

知识复习

一.spring

1.概念

Spring框架中的核心模块是IoC（Inversion of Control ，控制反转）和AOP（Aspect Oriented Programming，面向切面编程）。
1. IoC（控制反转）：IoC是Spring框架的核心特性之一，通过使用依赖注入，将对象的创建和依赖关系管理的责任从应用程序代码中解耦。通过IoC容器，我们可以将对象的创建和组装交由Spring框架来负责，使应用程序更加灵活、可测试和可维护。
2. AOP（面向切面编程）：AOP是Spring框架的另一个核心特性，它通过将与业务逻辑无关的横切关注点（如日志、安全性、事务管理）从业务逻辑中分离出来，实现了关注点的模块化。通过使用AOP，我们可以通过声明方式将这些横切关注点应用到我们的应用程序中，而不需要修改业务逻辑代码。
2.常用注解
1. @Configuration: 标记一个类为配置类，用于替代XML配置文件。
  
  示例：
```
@Configuration
public class AppConfig {
    // 配置Bean的方法
}
```
2. @Bean: 标记一个方法产生一个Bean对象，并由Spring容器进行管理。
  
  示例：
```
@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserService();
    }
}
```
3. @Scope: 定义Bean的作用范围，默认为单例。
  
  示例：
```
@Component
@Scope("prototype")
public class UserService {
    // 类的具体实现
}
```
4. @Value: 注入一个值到Bean中，可以是基本类型、字符串、引用等。
  
  示例：
```
@Component
public class UserService {
    @Value("John Doe")
    private String userName;
    
    // 其他方法
}
```
5. @Qualifier: 当存在多个相同类型的Bean时，通过该注解指定注入的Bean。
  
  示例：
```
@Autowired
@Qualifier("userRepository")
private UserRepository userRepository;
```
6. @PostConstruct: 在Bean实例化后执行初始化方法。
  
  示例：
```
@Component
public class UserService {
    @PostConstruct
    public void init() {
        // 初始化逻辑
    }
}
```
7. @PreDestroy: 在Bean销毁前执行清理操作。
  
  示例：
```
@Component
public class UserService {
    @PreDestroy
    public void cleanup() {
        // 清理逻辑
    }
}
```
8.@component注解

@Component是Spring中最常用的注解之一，用于标记一个类为组件类，并由Spring容器进行管理。

它的派生注解有以下几种：
1. @Controller: 标记一个类为控制器（Web MVC）。
  
  示例：
```
@Controller
public class UserController {
    // 控制器的具体实现
}
```
2. @Service: 标记一个类为服务类，通常用于业务逻辑的处理。
  
  示例：
```
@Service
public class UserService {
    // 服务类的具体实现
}
```
3. @Repository: 标记一个类为存储库类，用于数据持久化。
  
  示例：
```
@Repository
public class UserRepository {
    // 存储库类的具体实现
}
```
3.@componentsacn

@ComponentScan是一个Spring框架提供的注解，用于指定要扫描的包路径，将被@Component、@Controller、@Service、@Repository等注解标注的类注册为Spring容器中的Bean。通过@ComponentScan注解，可以自动扫描并注册指定包路径下的所有符合条件的组件。

@ComponentScan注解通常用在Spring配置类上，作为配置类的注解之一。通过在配置类上添加@ComponentScan注解并指定要扫描的包路径，Spring容器会自动扫描并注册指定包路径下的所有组件。

例如：
```
@Configuration
@ComponentScan("com.example.demo")
public class AppConfig {
    //其他配置信息
}
```
上述代码中，使用@ComponentScan注解指定要扫描的包路径为"com.example.demo"，Spring容器会自动扫描并注册该包路径下的所有组件，包括被@Component、@Controller、@Service、@Repository等注解标注的类。

需要注意的是，@ComponentScan注解还可以通过其属性basePackages和value来指定多个包路径进行扫描，以及通过excludeFilters和includeFilters属性来指定过滤条件进行筛选注册的组件。

4.aop

在Spring中使用AOP，不使用XML配置和Spring Boot。可以按照以下步骤进行配置：
1. 创建一个切面类，使用@Aspect注解标注，并添加@Component注解使其成为Spring的组件：
```
@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.demo.service.*.*(..))")
    public void beforeMethodCall(JoinPoint joinPoint) {
        // 在方法调用前执行的逻辑
        String methodName = joinPoint.getSignature().getName();
        System.out.println("Before method call: " + methodName);
    }
    // 其他通知方法...
}
```
1. 创建一个配置类，使用@Configuration注解标注，并添加@ComponentScan注解指定要扫描的包路径：
```
@Configuration
@ComponentScan(basePackages = "com.example.demo")
public class AppConfig {
}
```
1. 在Spring应用上下文中加载配置类并启动：
```
public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        // 获取切面类作为bean并使用
        LoggingAspect loggingAspect = context.getBean(LoggingAspect.class);
        // 调用业务方法
        SomeService someService = context.getBean(SomeService.class);
        someService.doSomething();
        context.close();
    }
}
```
通过以上配置，可以实现在Spring中使用AOP，切面类中定义的通知方法将在相应的切点被触发时执行逻辑。

注意：在配置类中使用@ComponentScan注解指定要扫描的包路径，以确保Spring能够扫描到切面类作为组件进行注册和使用

二.mybatis-plus

概念：

MyBatis-Plus是基于MyBatis的增强工具，提供了更方便、更强大的功能来简化数据库访问的开发。

以下是MyBatis-Plus的一些主要概念：
1. 实体（Entity）：在MyBatis-Plus中，实体是与数据库中的表相映射的Java对象。实体类通常包含表中的字段对应的属性，并使用注解来指定与数据库表的映射关系。
2. Mapper：Mapper是用于执行具体SQL操作的接口。使用MyBatis-Plus时，可以通过继承BaseMapper接口来轻松地实现常见的CRUD操作，也可以自定义SQL语句。
3. Service：Service是用于封装业务逻辑的组件。MyBatis-Plus提供了BaseService接口，可以用于快速创建Service类，也提供了常用的查询、更新等方法。
4. Wrapper：Wrapper是用于创建查询条件的封装类。MyBatis-Plus中的Wrapper接口提供了一系列的方法，可以根据具体需求灵活地构建查询条件，如eq、like、gt等方法。
5. 自动填充（MetaObjectHandler）：MyBatis-Plus提供了自动填充功能，可以在插入和更新实体时自动填充额外的字段，如创建时间、更新时间等。可以通过实现MetaObjectHandler接口来自定义填充的逻辑。
6. 分页支持：MyBatis-Plus提供了方便的分页查询功能，可以通过Page对象进行分页查询，并提供了一系列的Pageable方法进行分页参数的设置。
7. 主键策略：MyBatis-Plus支持多种主键策略，如自增、UUID、雪花算法等。可以通过注解@TableId来指定主键字段，并使用@KeySequence注解来配置主键生成策略。
通过使用MyBatis-Plus，可以简化数据库访问的开发，提高开发效率，并提供了更多的功能和扩展点，使得开发工作更加便捷。

1.常见配置yaml

以下是一个示例的 MyBatis-Plus 的 yaml 配置文件：
```
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/testdb?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
mybatis-plus:
  configuration:
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  # 分页配置
  pagehelper:
    helper-dialect: mysql
    reasonable: true
    support-methods-arguments: true
    params: count=countSql
  # 逻辑删除配置
  global-config:
    db-config:
      logic-delete-field: is_deleted
      logic-delete-value: 1
      logic-not-delete-value: 0
  # 主键策略配置
  global-config:
    db-config:
      id-type: auto
```
2.设置雪花主键

要在 MyBatis-Plus 中使用注解方式设置雪花主键生成器，可以按照以下步骤进行设置：
1. 1在实体类中使用 @TableId 注解标注主键字段，并设置主键生成策略为 IdType.ASSIGN_ID，同时指定一个自定义的主键生成器。
```
@Data
@TableName("your_table")
public class YourEntity {
    @TableId(value = "id", type = IdType.ASSIGN_ID, generator = "snowflake")
    private Long id;
    
    // 其他字段...
}
```
1. 2创建一个自定义的主键生成器类，实现 IdentifierGenerator 接口，并重写 nextId 方法来生成雪花算法的主键。
```
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.core.incrementer.IdentifierGenerator;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
public class SnowflakeGenerator implements IdentifierGenerator {
    @Override
    public Number nextId(Object entity) {
        return IdWorker.getId();
    }
    @Override
    public String nextUUID(Object entity) {
        return IdWorker.get32UUID();
    }
    @Override
    public Object nextId(Object entity, String fieldName) {
        return IdWorker.getId();
    }
}
```
1. 3启动类或配置类中使用 @Bean 注解来注册自定义的主键生成器。
```
@Configuration
public class MybatisPlusConfig {
    @Bean
    public IdentifierGenerator snowflake() {
        return new SnowflakeGenerator();
    }
}
```
通过以上设置，在使用 MyBatis-Plus 进行插入操作时，会自动调用雪花主键生成器生成全局唯一的 ID 作为主键值，并将其赋给实体类中的 id 字段

3.分页配置

要在 MyBatis-Plus 中使用分页插件，可以按照以下步骤进行设置：
1. 添加依赖：在项目的 POM 文件中添加 MyBatis-Plus 分页插件的依赖。
```
<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-boot-starterartifactId>
    <version>{version}version>
dependency>
```
1. 配置分页插件：在启动类或配置类中添加 PaginationInterceptor 的 Bean，来启用分页插件。
```
@Configuration
public class MybatisPlusConfig {
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}
```
1. 使用分页查询：在需要分页查询的方法中使用 Page 类进行分页操作。
```
@Service
public class YourService {
    @Autowired
    private YourMapper yourMapper;
    
    public IPage getPageData(Integer pageNum, Integer pageSize) {
        // 创建分页对象
        Page page = new Page<>(pageNum, pageSize);
        
        // 执行分页查询，结果会自动封装在 page 对象中
        IPage pageData = yourMapper.selectPage(page, null);
        
        return pageData;
    }
}
```
1. 获取分页结果：通过分页对象的方法可以获取到分页的相关信息和查询结果。
```
IPage pageData = yourService.getPageData(1, 10);
long total = pageData.getTotal(); // 获取总记录数
List records = pageData.getRecords(); // 获取当前页的记录列表
// 分页信息
long current = pageData.getCurrent(); // 当前页码
long pages = pageData.getPages(); // 总页数
long size = pageData.getSize(); // 每页记录数
boolean hasPrevious = pageData.hasPrevious(); // 是否有前一页
boolean hasNext = pageData.hasNext(); // 是否有下一页
```
4.代码生成器

下面是一个使用 MyBatis-Plus 代码生成器生成代码的示例，不使用 XML 配置文件，并且每行都有注释说明：

1.依赖
```
<dependency>
    <groupId>com.baomidougroupId>
    <artifactId>mybatis-plus-generatorartifactId>
    <version>{version}version>
dependency>
```
2.示例
```
import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.core.MybatisConfiguration;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.rules.DateType;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import org.apache.ibatis.type.JdbcType;
public class Generator {
    public static void main(String[] args) {
        // 数据源配置
        DataSourceConfig dataSourceConfig = new DataSourceConfig.Builder("jdbc:mysql://localhost:3306/db_name", "root", "root")
                .driver(DbType.MYSQL.getDriver()) // 设置数据库类型
                .type(DbType.MYSQL) // 设置数据库类型
                .build();
        // 全局配置
        GlobalConfig globalConfig = new GlobalConfig.Builder()
                .outputDir(System.getProperty("user.dir") + "/src/main/java") // 设置输出目录
                .author("Your Name") // 设置作者
                .openDir(true) // 生成完成后是否打开输出目录
                .dateType(DateType.ONLY_DATE) // 设置日期类型
                .idType(IdType.AUTO) // 设置主键类型
                .fileOverride(true) // 是否覆盖已有文件
                .build();
        // 包名配置
        PackageConfig packageConfig = new PackageConfig.Builder()
                .parent("com.example") // 设置父包名
                .moduleName("demo") // 设置模块名
                .entity("entity") // 设置实体类包名
                .mapper("mapper") // 设置Mapper接口包名
                .service("service") // 设置Service类包名
                .controller("controller") // 设置Controller类包名
                .build();
        // 策略配置
        StrategyConfig strategyConfig = new StrategyConfig.Builder()
                .naming(NamingStrategy.underline_to_camel) // 数据库表映射到实体的命名策略，下划线转驼峰命名
                .columnNaming(NamingStrategy.underline_to_camel) // 数据库表字段映射到实体类属性的命名策略，下划线转驼峰命名
                .entityTableFieldAnnotationEnable(true) // 是否生成实体类字段注解
                .entityLombokModel(true) // 是否使用Lombok注解
                .controllerRestStyle(true) // 是否生成@RestController风格控制器
                .controllerMappingHyphenStyle(true) // 是否驼峰转连字符
                .build();
        // 代码生成器
        AutoGenerator generator = new AutoGenerator(dataSourceConfig)
                .global(globalConfig)
                .packageInfo(packageConfig)
                .strategy(strategyConfig)
                .template(new TemplateConfig.Builder().build()); // 使用默认模板配置
        // 执行生成的代码
        generator.execute();
    }
}
```
5.公共字段自动填充

下面是一个使用 MyBatis-Plus 实现公共字段自动填充的示例：

首先，定义一个公共字段填充处理器：
```
import com.baomidou.mybatisplus.core.handlers.MetaObjectHandler;
import org.apache.ibatis.reflection.MetaObject;
import org.springframework.stereotype.Component;
import java.time.LocalDateTime;
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
    @Override
    public void insertFill(MetaObject metaObject) {
        // 设置创建时间和更新时间字段的值为当前时间
        this.setFieldValByName("createTime", LocalDateTime.now(), metaObject);
        this.setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }
    @Override
    public void updateFill(MetaObject metaObject) {
        // 设置更新时间字段的值为当前时间
        this.setFieldValByName("updateTime", LocalDateTime.now(), metaObject);
    }
}
```
然后，在实体类中添加对应的公共字段，并使用 @TableField 注解进行配置：
```
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import java.time.LocalDateTime;
@Data
@TableName("user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
    private String password;
    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;
}
```
最后，在启动类中将公共字段填充处理器添加到 MyBatis-Plus 的自动填充处理器列表中：
```
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
@MapperScan("com.example.mapper")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}
```
6.Lambda查询

MyBatis-Plus 提供了 Lambd 查询，通过使用 Lambda 表达式，可以更加简洁地进行条件查询。下面是一些常见的 Lambd 查询示例：
1. 等值查询：
```
// 使用 lambda 进行等值查询
List userList = userMapper.selectList(Wrappers.lambdaQuery().eq(User::getUsername, "admin"));
```
1. 模糊查询：
```
// 使用 lambda 进行模糊查询
List userList = userMapper.selectList(Wrappers.lambdaQuery().like(User::getUsername, "adm"));
```
1. 多条件查询：
```
// 使用 lambda 进行多条件查询
List userList = userMapper.selectList(Wrappers.lambdaQuery()
    .eq(User::getGender, "男")
    .like(User::getUsername, "adm")
    .lt(User::getAge, 30));
```
1. 自定义查询条件：
```
// 使用 lambda 自定义查询条件
List userList = userMapper.selectList(Wrappers.lambdaQuery()
    .eq(User::getGender, "男")
    .and(queryWrapper -> queryWrapper.like(User::getUsername, "adm").or().like(User::getEmail, "test")));
在以上示例中，User::getUsername、User::getGender 等方法引用代表了实体类的属性，可使用 lambda 表达式构建查询条件。
 
除了查询方法使用了 lambda 之外，还可以使用 UpdateWrapper 进行更新操作，示例代码如下：
 
// 使用 lambda 进行更新操作
userMapper.update(null, Wrappers.lambdaUpdate()
        .set(User::getUsername, "admin")
        .eq(User::getId, 1));
```
以上示例演示了一些常见的 Lambd 查询用法，使用 MyBatis-Plus 的 Lambd 查询可以大大简化查询条件的编写，提高开发效率。

三.Mybatis

概念：

MyBatis是一个开源的持久化框架，简化了数据库访问开发。它提供了一种将SQL语句与Java方法绑定的方式，使开发人员可以轻松地配置和执行数据库操作。

以下是MyBatis的一些关键概念：
1. Mapper XML：Mapper XML是配置SQL语句的地方。它包含了与数据库交互的具体SQL语句，以及SQL语句与Java方法之间的映射关系。
2. Mapper接口：Mapper接口定义了与数据库交互的方法。通过在接口方法上使用注解，可以将SQL语句绑定到方法上。
3. SqlSession：SqlSession是MyBatis与数据库交互的核心类。它提供了数据库操作的方法，如查询、插入、更新等。开发人员可以通过SqlSession执行Mapper接口中定义的方法。
4. ParameterHandler：ParameterHandler负责处理SQL语句的参数。它将Java对象转换为符合JDBC标准的参数，并将其传递给底层的JDBC驱动程序。
5. ResultSetHandler：ResultSetHandler负责处理查询结果。它将JDBC查询结果转换为Java对象，并将其返回给应用程序。
6. Executor：Executor负责执行SQL语句。它根据配置可以使用不同的执行策略，如简单、批处理或重用等。
1.xmlMapper文件

MyBatis 的 XML Mapper 文件是用来定义 SQL 映射关系以及提供 SQL 查询、插入、更新、删除等操作的地方。通常一个实体类对应一个 XML Mapper 文件，其命名规则是实体类名加上 Mapper.xml 后缀。

XML Mapper 文件的基本结构如下：
```
mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.UserMapper">
    
    <select id="selectUser" resultType="User">
        SELECT * FROM user WHERE id = #{id}
    select>
    
    <insert id="insertUser" parameterType="User">
        INSERT INTO user (username, password) VALUES (#{username}, #{password})
    insert>
    
    <update id="updateUser" parameterType="User">
        UPDATE user SET username = #{username}, password = #{password} WHERE id = #{id}
    update>
    
    <delete id="deleteUser" parameterType="int">
        DELETE FROM user WHERE id = #{id}
    delete>
mapper>
```
2.动态sql

在 MyBatis 的 XML Mapper 文件中，可以使用动态 SQL 来根据条件生成不同的 SQL 语句。这样可以实现在同一个 SQL 查询中根据不同的条件进行灵活地拼接和生成不同的查询语句。

动态 SQL 主要通过以下几个标签来实现：
1. ：用于条件判断，根据给定的条件判断是否包含其中的 SQL 语句。
```
<select id="selectUser" parameterType="Map" resultType="User">
  SELECT * FROM user
  WHERE
    <if test="username != null">username = #{username}if>
    <if test="gender != null">AND gender = #{gender}if>
select>
```
在上面的例子中，如果传入的参数 username 和 gender 都不为空，那么最终生成的 SQL 语句将是 SELECT * FROM user WHERE username = #{username} AND gender = #{gender}。
1. 、、：用于条
```
<select id="selectUser" parameterType="Map" resultType="User">
  SELECT * FROM user
  <choose>
    <when test="id != null">WHERE id = #{id}when>
    <when test="username != null">WHERE username = #{username}when>
    <otherwise>WHERE gender = #{gender}otherwise>
  choose>
select>
```
  件选择，根据给定的条件选择其中的一个分支执行。
在上面的例子中，根据传入的参数中的 id、username 和 gender 的值，选择不同的分支执行，生成不同的 SQL 语句。
1. ：用于循环处理，将一个集合中的元素逐个拼接到 SQL 语句中。
```
<delete id="deleteByIdList" parameterType="List">
  DELETE FROM user
  WHERE id IN
  <foreach collection="list" item="id" separator="," open="(" close=")">
    #{id}
  foreach>
delete>
```
5:用于条件处理
```
  SELECT * FROM user      AND username = #{username}    AND gender = #{gender}   
```
3.自定义返回类型

在 XML Mapper 文件中，可以使用标签来定义自定义的结果映射。通过标签，可以指定查询结果中的列和对象属性之间的映射关系，并定义如何处理结果。

以下是一个示例：
```
<resultMap id="userResultMap" type="com.example.User">
  <id property="id" column="user_id"/>
  <result property="username" column="user_name"/>
  <association property="address" javaType="com.example.Address">
    <id property="id" column="address_id"/>
    <result property="city" column="address_city"/>
    <result property="country" column="address_country"/>
  association>
resultMap>
```
在以上示例中，定义了一个名为 "userResultMap" 的结果映射，指定了 User 类型的结果。通过标签可以指定列和对象属性之间的映射关系，通过标签可以描述对象之间的关联关系。

然后，在相应的 SQL 查询语句中，可以使用标签来引用定义好的结果映射：
```
<select id="selectUser" parameterType="int" resultMap="userResultMap">
  SELECT * FROM user WHERE id = #{id}
select>
```
在以上示例中，

知识复习

一.spring

1.概念

2.常用注解

3.@componentsacn

4.aop

二.mybatis-plus

概念：

1.常见配置yaml

2.设置雪花主键

3.分页配置

4.代码生成器

5.公共字段自动填充

6.Lambda查询

三.Mybatis

概念：

1.xmlMapper文件

2.动态sql

3.自定义返回类型