SSM

2022-07-26
作者 GLK
~67.60K 字

spring官网

Spring

Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基

学习路线

核心容器的核心概念

代码书写现状
- 代码耦合度高
解决方案
- 使用对象时，在程序中不要主动使用new产生对象，转换为由外部提供对象
IoC(Inversion of Control) 控制反转
- 对象的创建控制权由程序转移到外部，这种思想称为控制反转
- 目标：解耦
Spring技术对IoC思想进行了实现
- Spring提供了一个容器，称为IoC容器，用来充当IoC思想的外部
- IoC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean
DI(Dependency Injection)依赖注入
- 在容器中建立bean与bean之间的依赖关系的整个过程，称为依赖注入

本节总结：

目标：充分解耦
- 在IoC容器中管理bean（IoC）
- 在IoC容器内将有依赖关系的bean进行关系绑定（DI）
最终效果
- 使用对象时不仅可以直接从IoC容器中获取，并且获取的bean已经绑定了所有的依赖关系

IoC入门案例思路分析

1.管理什么？(Service与Dao)

2.如何将被管理的对象告知IoC容器？(配置)

3.被管理的对象交给IoC容器，如何获取到IoC容器？(接口)

4.IoC容器得到后，如何从容器中获取bean？(接口方法)

5.使用Spring时怎么导入坐标(pom.xml)

使用步骤：

1.导jar包

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.10.RELEASE</version>
</dependency>

2.定义spring管理的类（接口）

3.创建Spirng配置文件，配置对应类作为Spring管理的bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="bookDaoBean" class="com.itheima.dao.impl.BookDaoImpl"/>
    <bean id="bookServiceBean" class="com.itheima.service.impl.BookServiceImpl"/>
</beans>

注意事项：bean定义式id属性在同一个上下文中不能重复

4.初始化IoC容器，通过容器获取bean

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

需要获取的对象的类型 bookDao = (需要获取的对象类型)applicationContext.getBean("bookDaoBean");

applicationContext.getBean(“”)获取的是一个Object类型的对象，应对其进行强制类型转换

DI入门案例

1.基于IoC管理bean

2.Service中使用new形式创建的Dao对象是否保留？(否)

3.Service中需要的Dao对象如何进入到Service中？(提供方法)

4.Service与Dao间的关系如何描述？(配置)

使用步骤：

1.删除使用new的形式创建对象的代码

private BookDao bookDao ~~= new BookDaoImpl()~~;

public void save(){
System.out.println(“book service 。。。”);
bookDao.save();
}

2.提供依赖对象对应的setter方法

public class BookServiceImpl implements BookService {

    private BookDao bookDao;

    public void save(){
        System.out.println("book service 。。。。。。");
        bookDao.save();
    }

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

3.配置service与dao之间的关系

<bean id="bookServiceBean" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDaoBean"/>
</bean>
// property 标签中 name是 id="bookServiceBean"对象里属性的名称   ref则是bean对象的名称

bean基础配置

别名配置

姓名：name

类型：属性

所属：bean标签

范例

<bean id="bookServiceBean" name="FirstBean,SecondBean" class="com.itheima.service.impl.BookServiceImpl">
        <property name="bookDao" ref="bookDaoBean"/>
    </bean>

注意事项

获取bean无论是通过id还是name获取，如果无法获取到，将抛出异常NoSuchBeanDefinitionException

NoSuchBeanDefinitionException: No bean named ‘bookServiceImpl’ available

bean作用范围说明

可见，Spring默认给我们创建的bean是一个单例模式，

我们可以通过在 bean标签中设置属性 scope=”prototype”来讲bean设置成非单例

适合交给容器进行管理的bean
- 表现层对象
- 业务层对象
- 数据层对象
- 工具对象
不适合交给容器进行管理的bean
- 封装实体的域对象

单例bean与原型bean的区别

单例bean：如果一个bean被声明为单例的时候，在处理多次请求的时候在Spring容器里只实例化出一个bean，后续的请求都公用这个对象，这个对象会保存在一个map里面。
当有请求来的时候会先从缓存(map)里查看有没有，有的话直接使用这个对象，没有的话才实例化一个新的对象，所以这是个单例的。（ThreadLocal ）创建完后，后面都会复用这个bean

原型(prototype)bean来说当每次请求来的时候直接实例化新的bean，没有缓存以及从缓存查的过程。

结论：

单例的bean只有第一次创建新的bean 后面都会复用该bean，所以不会频繁创建对象。

原型的bean每次都会新创建

单例bean的优势
由于不会每次都新创建新对象所以有一下几个性能上的优势：

1.减少了新生成实例的消耗
新生成实例消耗包括两方面，第一，Spring会通过反射或者cglib来生成bean实例这都是耗性能的操作，其次给对象分配内存也会涉及复杂算法。

2.减少jvm垃圾回收
由于不会给每个请求都新生成bean实例，所以自然回收的对象少了。

3.可以快速获取到bean
因为单例的获取bean操作除了第一次生成之外其余的都是从缓存里获取的所以很快。

单例bean的劣势
单例的bean一个很大的劣势就是他不能做到线程安全！！！尤其是高并发情况下。

由于所有请求都共享一个bean实例，所以这个bean要是有状态的一个bean的话可能在并发场景下出现问题，而原型的bean则不会有这样问题（但也有例外，比如他被单例bean依赖），因为给每个请求都新创建实例。

bean实例化的三种方式

构造方法（常用）

bean本质上就是对象，创建bean使用构造方法完成

public class BookDaoImpl implements BookDao {

//    private BookDaoImpl(){
//        System.out.println("book dao struct is running......");
//    }
    public void save() {
        System.out.println("BookDao 我他吗来啦");
    }
}

提供可访问的构造方法

<bean id="bookDaoBean" class="com.itheima.dao.impl.BookDaoImpl"/>

静态工厂（了解）

实例工厂

FactoryBean（实用）

bean生命周期

生命周期：从创建到销毁的完整过程
bean生命周期控制：在bean创建后到销毁前做一些事情

接口控制（了解）

bean生命周期

初始化容器

1.创建对象（内存分配）

2.执行构造方法

3.执行属性注入（set操作）

4.执行bean初始化方法
使用bean

1.执行业务操作
关闭/销毁容器

1.执行bean销毁方法

bean销毁时机

容器关闭前触发bean的销毁
关闭容器方式：
- 手工关闭容器
  
  ConfigurableApplicationContext接口close（）方法
- 注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
  
  ConfigurableApplicationContext接口registerShutdownHook（）操作

依赖注入方式

思考：向一个类中传递数据的方式有几种？
- 普通方法（set方法）
- 构造方法
思考：依赖注入描述了在容器中简历bean与bean之间依赖关系的过程，如果bean运行需要的是数据或字符串呢？
setter注入
- 简单类型
- 引用类型
构造器注入
- 简单类型
- 引用类型

依赖注入方式选择

1.强制依赖使用构造器进行，使用setter注入有概率不进行注入导致null对象出现

2.可选依赖使用setter注入进行，灵活性强

3.Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨

4.如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入

5.实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入

6.自己开发的模块推荐使用setter注入

自动装配

IoC容器根据bean所以来的资源在容器中自动查找并注入到bean中的过程称为自动装配
自动装配方式
- 按类型（常用）
- 按名称
- 按构造方法
- 不启用自动装配
配种中使用bean标签autowire

自动装配用于引用类型依赖注入，不能对简单类型进行操作
使用按类型装配时(byType)必须保障容器中想同类型的bean唯一，推荐使用
使用按名称装配时(byName)必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效

集合注入

数组，List，Set，Map,Properties

bean所依赖的实现类

public class BookDaoImpl implements BookDao {

    private int[] array;

    private List<String> list;

    private Set<String> set;

    private Map<String,String> map;

    private Properties properties;




    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }




    public void save() {
        System.out.println("book dao save ...");

        System.out.println("遍历数组:" + Arrays.toString(array));

        System.out.println("遍历List" + list);

        System.out.println("遍历Set" + set);

        System.out.println("遍历Map" + map);

        System.out.println("遍历Properties" + properties);
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <!--数组注入-->
        <property name="array">
            <array>
                <value>100</value>
                <value>200</value>
                <value>300</value>
            </array>
        </property>
        <!--list集合注入-->
        <property name="list">
            <list>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>chuanzhihui</value>
            </list>
        </property>
        <!--set集合注入-->
        <property name="set">
            <set>
                <value>itcast</value>
                <value>itheima</value>
                <value>boxuegu</value>
                <value>boxuegu</value>
            </set>
        </property>
        <!--map集合注入-->
        <property name="map">
            <map>
                <entry key="country" value="china"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <!--Properties注入-->
        <property name="properties">
            <props>
                <prop key="country">china</prop>
                <prop key="province">henan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>
</beans>

第三方资源配置管理

导入druid坐标

<dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

配置数据源对象作为spring管理的bean

<bean class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
        <property name="username" value=""/>
        <property name="password" value=""/>
</bean>

加载properties文件

由于上次学习将数据库的用户名，密码，全配置在applicationContext.xml之中，非常的危险，故应该使用properties文件记录数据库信息

1.开启context命名空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            ">
    <!--  将含有beans的代码复制一份并用context替换beans-->

2.使用context空间加载properties文件

<context:property-placeholder location="classpath*:*.properties" system-properties-mode="NEVER"/>

使用属性占位符${}读取properties文件中的属性

<bean class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.Driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
</bean>

4.自己配置的 jdbc.properties文件内容

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

容器

创建容器

获取bean

容器类结构层次

BeanFactory

类路径加载配置文件

核心容器总结

BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载
ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载
ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
ApplicationContext接口常用初始化类
- ClassPathXmlApplicationContext
- FileSystemXmlApplicationContext

bean相关

依赖注入相关

注解开发

注解开发定义bean

同时这几个注解后面也可以添加一些参数，比如比较常用的一个是注解的括号中加value属性，来表示这个组件在容器中的ID，如果不设置value值时，默认的ID是类名的全称（第一个字母小写）。

在这里有一点需要注意：事实上Spring并没有能力识别一个组件到底是不是它所标记的类型，即使将@Respository注解用在一个表述层控制器组件上面也不会产生任何错误，所以@Respository、@Service、@Controller这几个注解仅仅是为了让开发人员自己明确当前的组件扮演的角色。方便将组件加入到容器中去。

纯注解开发

Spring3.0升级了纯注解开发模式，使用java类替代配置文件，开启了Spring快速开发赛道

读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象

//加载配置文件初始化容器
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//加载配置类初始化容器    
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

Java类替代Spring核心配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.itheima"/>

</beans>


//配置文件被替换为


//声明当前类为Spring配置类
@Configuration
//设置bean扫描路径，多个路径书写为字符串数组格式
@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}

@Configuration注解用于设定当前类为配置类
@ComponentScan注解用于设定扫描路径，次注解只能添加一次，多个数据请用数组格式
```
@ComponentScan({"com.itheima.service","com.itheima.dao"})
```

注解开发小结

1.定义bean

@Component
- @Controller
- @Service
- @Repository
<context:component-scan/>

2.纯注解开发

@Configuration
@ComponentScan
AnnotationConfigApplicationContext

bean作用范围与生命周期管理

使用@Scope定义bean作用范围

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao{
}

使用@PostConstruct、@PreDestroy定义bean生命周期

@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao{
	public BookDaoImpl(){
		System.out.println("book dao constructor ...");
	}
    @PostConstruct
    public void init(){
        System.out.println("book init ...");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("book destroy ...")
    }
}

依赖注入

使用@Autowired注解开发自动装配模式(按类型)

@Service
public class bookServiceImpl implements BookService{
	@Autowired
	private BookDao bookDao;
	
	public void save(){
		System.out.println("book service save ...");
		bookDao.save();
	}
}

注意：自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，隐藏无需提供setter方法
注意：自动装配建议使用无参构造方法创建对象(默认)，如果不提供对应构造对象，请提供唯一的构造方法

使用@Qualifier注解开启指定名称装配bean

@Service
public class BookServiceImpl implements BookService {
    //@Autowired：注入引用类型，自动装配模式，默认按类型装配
    @Autowired
    //@Qualifier：自动装配bean时按bean名称装配
    @Qualifier("bookDao")
    private BookDao bookDao;

    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

注意：@Qualifier注解无法单独使用，必须配合@Autowired注解使用

使用@Value实现简单类型注入

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    //@Value：注入简单类型（无需提供set方法）
    @Value("Hello World")
    private String name;

    public void save() {
        System.out.println("book dao save ..." + name);
    }
}

加载properties文件

使用@PropertySource注解加载properties文件

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
public class SpringConfig{
}

注意：路径仅支持单一文件配置，多文件请使用数组格式配置，不允许使用通配符*

第三方bean

第三方bean管理

使用@bean配置第三方bean

@Configuration
public class SpringConfig {

    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
      	ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
        ds.setUsername("root");
        ds.setPassword("1234");
        return ds;
    }
}

建议使用方式一，因为方式二看不出你用过哪些配置类

第三方bean依赖注入

简单类型依赖注入

public class JdbcConfig {
    //1.定义一个方法获得要管理的对象
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/spring_db")
    private String url;
    @Value("root")
    private String userName;
    @Value("root")
    private String password;
    //2.添加@Bean，表示当前方法的返回值是一个bean
    //@Bean修饰的方法，形参根据类型自动装配
    @Bean
    public DataSource dataSource(BookDao bookDao){
        System.out.println(bookDao);
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

引用类型依赖注入

@Bean
   public DataSource dataSource(BookDao bookDao){
       System.out.println(bookDao);
       DruidDataSource ds = new DruidDataSource();
       ds.setDriverClassName("com.mysql.jdbc.Driver");
       ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
       ds.setUsername("root");
       ds.setPassword("1234");
       return ds;
   }

引用类型注入只需要为bean定义方法设置形参即可，容器会根据类型自动装配对象

注解开发总结

XML配置对比注解配置

Spring整合mybatis

![](https://raw.githubusercontent.com/2295237514/image/main/20220802102956.png

Spring应该管理的bean是SqlsessionFactory

Spring整合junit

//设置类运行器
@RunWith(SpringJUnit4ClassRunner.class)
//设置Spring环境对应的配置类
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    //支持自动装配注入bean
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        System.out.println(accountService.findById(1));

    }
}

AOP

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程序结构
- OOP（Object Oriented Programming）面向对象编程
作用：在不惊动原始设计的基础上为其进行功能增强
Spring理念：无入侵式/无侵入式

AOP核心概念

连接点(JoinPoint):程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等
- 在SpringAop中，理解为方法的执行
切入点（Pointcut）：匹配连接点的式子
- 在SpringAOP中，一个切入点可以只描述一个具体方法，也可以匹配多个方法
  - 一个具体方法
  - 匹配多个方法：所有的save方法，所有的get开头的方法，所有以D奥结尾的接口中的任意方法，所有带有一个参数的方法
通知（Advice）：在切入点处执行的操作，也就是共性功能
- 在SpringAOP中，功能最终以方法的形式呈现
通知类：定义通知的类
切面(Aspect)：描述通知与切入点的对应关系
目标对象（Target）：原始功能去掉共性功能对应的类产生的对象，这种对象是无法完成最终工作的
代理（Proxy）：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

AOP入门案例思路分析

开发模式：XML 或注解

思路分析：

1.导入坐标（pom.xml）

2.制作连接点方法（原始操作，Dao接口与实现类）

3.制作共性功能（通知类与通知）

4.定义切入点

5.绑定切入点与通知关系（切面）

步骤

1.导入aop相关坐标

<dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.4</version>
    </dependency>

2.定义dao接口与实现类

public interface BookDao {
    public void save();
    public void update();
}

@Repository
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }

    public void update(){
        System.out.println("book dao update ...");
    }
}

3.定义通知类和切入点

说明：切入点定义依托一个不具有实际意义的方法进行，即无参数，无返回值，方法体无实际逻辑,

4.最后绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置

5.定义通知类受Spring容器管理，并定义当前类为切面类

@Component
//设置当前类为切面类类
@Aspect
public class MyAdvice {
    //设置切入点，要求配置在方法上方
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")
    private void pt(){}

    //设置在切入点pt()的前面运行当前操作（前置通知）
    // @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

6.开启Spring对AOP注解驱动支持

@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}

AOP工作流程

1.Spring容器启动

2.读取所有切面配置中的切入点

3.初始化bean，判定bean对应的类中的方法是否匹配到任意切入点

匹配失败，创建对象
匹配成功，创建原始对象(目标对象)的代理对象

4.获取bean执行方法

获取bean，调用方法并执行，完成操作
获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作

AOP切入点表达式

切入点：要进行增强的方法
切入点表达式：要进行增强的方法的描述方法

切入点表达式标准格式：动作关键字(访问修饰符返回值包名.类/接口名.方法名(参数)异常名)

execution(public User com.itheima.service.UserService.findById(int))

动作关键字：描述切入点的行为动作，例如execution表示执行到指定切入点
访问修饰符：public，private等，可以省略
返回值
包名
类/接口名
方法名
参数
异常名：方法定义中抛出指定异常，可以省略

*****：必有最少一个

..:可以没有，也可以有任意个

书写技巧

所有代码按照规范标准开发，否则以下技巧全部失效
描述切入点通常描述接口，而不描述实现类
访问控制修饰符针对接口开发均采用public描述(可省略访问控制修饰符描述)
返回值类型对于增删改类使用精准类型加速匹配，对于查询类使用*通配快速描述
包名书写尽量不使用**..*匹配，效率过低，常用做单个包描述匹配，或精准匹配
接口名/类型书写名称与模块相关的采用*匹配，例如UserService书写成*Service，绑定业务层接口
方法名书写以动词进行精准匹配，名次采用*匹配，例如getById书写成getBy*
参数规则较为复杂，根据业务方法灵活调整
通常不适用异常作为匹配规则

AOP通知类型

AOP通知描述了抽取的共性功能，根据共性功能抽取的位置不同，最终运行代码时要将其加入到合理的位置
AOP通知共分为5种类型
- 前置通知 @Before
- 后置通知 @After
- 环绕通知（重点） @Around
- 返回后通知（了解）@AfterReturning
- 抛出异常后通知（了解）@AfterThrowing

案例：测量业务层接口执行效率

@Component
@Aspect
public class ProjectAdvice {
    //匹配业务层的所有方法
    @Pointcut("execution(* com.itheima.service.*Service.*(..))")
    private void servicePt(){}

    //设置环绕通知，在原始操作的运行前后记录执行时间
    @Around("ProjectAdvice.servicePt()")
    public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
        //获取执行的签名对象
        Signature signature = pjp.getSignature();
        String className = signature.getDeclaringTypeName();
        String methodName = signature.getName();

        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
           pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("万次执行："+ className+"."+methodName+"---->" +(end-start) + "ms");
    }
}

AOP通知获取数据

获取切入点方法的参数、
- JoinPoint：适用于前置、后置、返回后、抛出异常后通知
- ProceedJoinPoint：适用于环绕通知
获取切入点方法返回值
- 返回后通知
- 环绕通知
获取切入点方法运行异常信息
- 抛出异常后通知
- 环绕通知

AOP总结

概念：AOP面向切面编程，一种编程范式
作用：在不惊动原始设计的基础上为方法进行功能增强
核心概念：
- 代理：SpringAOP的核心本质是采用代理模式实现的
- 连接点：在SpringAOP中，理解为任意方法的执行
- 切入点：匹配连接点的式子，也是具有共性功能的方法描述
  - 切入点表达式标准格式：动作关键字（访问修饰符返回值包名.类/接口名.方法名（参数）异常名）
    - execution(* com.itheima.service.*Service.*(..))
  - 切入点表达式描述通配符：
    - 作用：用于快速描述，范围描述
    - *：匹配任意符号（常用）
    - ..：匹配多个连续的任意符号(常用)
    - +：匹配子类类型
  - 切入点表达式书写技巧
    
    1.按标准规范开发
    
    2.查询操作的返回值建议使用*匹配
    
    3.减少使用..的形式描述包
    
    4.对接口进行描述，使用*表示模块名，例如UserService的匹配描述为*Service
    
    5.方法名书写保留动词，例如get,使用*表示名词，例如getById匹配描述为*getBy*
    
    6.参数根据实际情况灵活调整
- 通知：若干个方法的共性功能，在切入点处执行，具体体现为一个方法
  - 环绕通知：
    - 环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
    - 环绕通知可以隔离原始方法的调用执行
    - 环绕通知返回值设置为Object类型
    - 环绕通知中可以对原始方法调用过程中出现的异常进行处理
- 切面：描述通知与切入点的对应关系
- 目标对象：被代理的原始对象称为目标对象

事务

Spirng事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败

案例：银行账户转账

1.在业务层接口上添加Spring事务管理

public interface AccountService{
	@Transactional
	public void transfer(String out,String in,Double money);
}

注意事项

Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中，降低耦合
注解式事务可以添加到业务方法上表示当前方法开启事务，也可以添加到接口上表示当前接口所有方法开启事务

2.设置事务管理器

@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
	DataSourceTransactionManager ptm = new DataSourceTransactionManager();
	ptm.setDataSource(dataSource);
    return ptm;
}

注意事项

事务管理器要根据实现技术进行选择
MyBatis框架使用的是JDBC事务

3.开启注解式事务驱动

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}

Spring事务角色

事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法
事务协调员：加入事务方，在Spring中通常代指数据层方法，也可以是业务层方法

事务相关配置

有些异常默认事务不回滚，如IOEXCEPTION需手动设置 roolbackFor属性

案例：转账业务追加日志

1.在业务层接口上添加Spring事务，设置事务传播行为REQUIRES_NEW(需要新事物)

@Service
public class LogServiceImpl implements LogService {

    @Autowired
    private LogDao logDao;
	
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void log(String out,String in,Double money ) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

事务传播行为

SpringMVC

SpringMVC技术与Servlet技术功能等同，均属于web层开发技术
SpringMVC是一种基于java实现MVC模型的轻量级Web框架
优点
- 使用简单，开发便捷（相比于Servlet）
- 灵活性强

学习目标：

1.掌握基于SpringMVC获取请求参数与响应json数据操作

2.熟练应用基于REST风格的请求路径设置与参数传递

3.能够根据实际业务简历前后端开发通讯协议并进行实现

4.基于SSM整合技术开发任意业务模块功能

SpringMVC入门案例

1.使用SpringMVC技术需要先导入SpringMVC坐标与Servlet坐标

<dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
      <scope>provided</scope>
</dependency>
<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.2.10.RELEASE</version>
</dependency>

2.创建SpringMVC控制器类（等同于Servlet功能）

@Controller
public class UserController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'info':'springmvc'}";
    }
}

3.初始化SpringMVC环境（同Spring环境），设定SpringMVC加载对应的bean

@Configuration
@ComponentScan("com.itheima.controller")
public class SpringMvcConfig{

}

知识点1：@Controller

名称	@Controller
类型	类注解
位置	SpringMVC控制器类定义上方
作用	设定SpringMVC的核心控制器bean

知识点2：@RequestMapping

名称	@RequestMapping
类型	类注解或方法注解
位置	SpringMVC控制器类或方法定义上方
作用	设置当前控制器方法请求访问路径
相关属性	value(默认)，请求访问路径

知识点3：@ResponseBody

名称	@ResponseBody
类型	类注解或方法注解
位置	SpringMVC控制器类或方法定义上方
作用	设置当前控制器方法响应内容为当前返回值，无需解析

注意事项

SpringMVC是基于Spring的，在pom.xml只导入了spring-webmvcjar包的原因是它会自动依赖spring相关坐标
AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
AbstractDispatcherServletInitializer提供了三个接口方法供用户实现
- createServletApplicationContext方法，创建Servlet容器时，加载SpringMVC对应的bean并放入WebApplicationContext对象范围中，而WebApplicationContext的作用范围为ServletContext范围，即整个web容器范围
- getServletMappings方法，设定SpringMVC对应的请求映射路径，即SpringMVC拦截哪些请求
- createRootApplicationContext方法，如果创建Servlet容器时需要加载非SpringMVC对应的bean,使用当前方法进行，使用方式和createServletApplicationContext相同。
- createServletApplicationContext用来加载SpringMVC环境
- createRootApplicationContext用来加载Spring环境

入门案例工作流程分析

启动服务器初始化过程

1.服务器启动，执行ServletContainerInitConfig类，初始化web容器

2.执行createServletApplicationContext方法，创建了WebApplicationContext对象

3.加载SpringMvcConfig

4.执行@ComponentScan加载对应的bean

5.加载UserController，每个@RequestMapping的名称对应一个具体的方法

6.执行getServletMappings方法，定义所有的请求都通过SpringMVC
单次请求过程

1.发送请求localhost/save

2.web容器发现所有请求都经过SpringMVC，将请求交给SpringMVC处理

3.解析请求路径/save

4.由/save匹配执行对应的方法save()

5.执行save()

6.检测到有@ResponseBody直接将save()方法的返回值作为响应体返回给请求方

bean加载控制

方式一:修改Spring配置类，设定扫描范围为精准范围。

@Configuration
@ComponentScan({"com.itheima.service","comitheima.dao"})
public class SpringConfig {
}

方式二:修改Spring配置类，设定扫描范围为com.itheima,排除掉controller包中的bean

@Configuration
@ComponentScan(value="com.itheima",
    excludeFilters=@ComponentScan.Filter(
    	type = FilterType.ANNOTATION,
        classes = Controller.class
    )
)
public class SpringConfig {
}

excludeFilters属性：设置扫描加载bean时，排除的过滤规则

bean的加载格式：

public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMvcConfig.class);
        return ctx;
    }
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    protected WebApplicationContext createRootApplicationContext() {
      AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringConfig.class);
        return ctx;
    }
}

对于上述的配置方式，Spring还提供了一种更简单的配置方式，可以不用再去创建AnnotationConfigWebApplicationContext对象，不用手动register对应的配置类，如何实现?

简化开发的格式

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {

    protected Class<?>[] getRootConfigClasses() {
        return new Class[]{SpringConfig.class};
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
}

请求与响应

请求映射路径

优化映射路径

@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("user save ...");
        return "{'module':'user save'}";
    }
    
    @RequestMapping("/delete")
    @ResponseBody
    public String save(){
        System.out.println("user delete ...");
        return "{'module':'user delete'}";
    }
}

@Controller
@RequestMapping("/book")
public class BookController {

    @RequestMapping("/save")
    @ResponseBody
    public String save(){
        System.out.println("book save ...");
        return "{'module':'book save'}";
    }
}

注意:

当类上和方法上都添加了@RequestMapping注解，前端发送请求的时候，要和两个注解的value值相加匹配才能访问到。
@RequestMapping注解value属性前面加不加/都可以

请求参数

Get请求
Post请求

Post请求中文乱码处理

为web容器添加过滤器并指定字符集，Spring-web包中提供了专用的字符过滤器

解决方法：配置过滤器

public class ServletContainersInitConfig extends AbstractAnnotationConfigDispatcherServletInitializer {
    protected Class<?>[] getRootConfigClasses() {
        return new Class[0];
    }

    protected Class<?>[] getServletConfigClasses() {
        return new Class[]{SpringMvcConfig.class};
    }

    protected String[] getServletMappings() {
        return new String[]{"/"};
    }

    //乱码处理
    @Override
    protected Filter[] getServletFilters() {
        CharacterEncodingFilter filter = new CharacterEncodingFilter();
        filter.setEncoding("UTF-8");
        return new Filter[]{filter};
    }
}

发送请求与参数:

http://localhost/commonParamDifferentName?name=张三&age=18

后台接收参数:

@RequestMapping("/commonParamDifferentName")
@ResponseBody
public String commonParamDifferentName(String userName , int age){
    System.out.println("普通参数传递 userName ==> "+userName);
    System.out.println("普通参数传递 age ==> "+age);
    return "{'module':'common param different name'}";
}

因为前端给的是name,后台接收使用的是userName,两个名称对不上，导致接收数据失败:

解决方案:使用@RequestParam注解

@RequestMapping("/commonParamDifferentName")
    @ResponseBody
    public String commonParamDifferentName(@RequestPaam("name") String userName , int age){
        System.out.println("普通参数传递 userName ==> "+userName);
        System.out.println("普通参数传递 age ==> "+age);
        return "{'module':'common param different name'}";
    }

用集合接收前台参数也需要@RequestParam注解

日期类型参数传递

类型转换器

json数据

接受请求中json数据

1.添加json数据转换相关坐标

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>

2.设置发送json数据(请求body中添加json数据)

3.开启自动转换json数据的支持

4.设置接收json数据

//使用@RequestBody注解将外部传递的json数组数据映射到形参的集合对象中作为数据
    @RequestMapping("/listParamForJson")
    @ResponseBody
    public String listParamForJson(@RequestBody List<String> likes){
        System.out.println("list common(json)参数传递 list ==> "+likes);
        return "{'module':'list common for json param'}";
    }

@RequestBody一个处理器方法只能使用一次

@RequestBody与@RequestParam区别

区别
- @RequestParam用于接收url地址传参，表单传参
- @RequestBody用于接收json数据
应用
- 后期开发中，发送json格式数据为主，@RequestBody应用较广
- 如果发送非json格式数据，选用@RequestParam接收请求参数

名称	@ResponseBody
类型	==方法\类注解==
位置	SpringMVC控制器方法定义上方和控制类上
作用	设置当前控制器返回值作为响应体, 写在类上，该类的所有方法都有该注解功能
相关属性	pattern：指定日期时间格式字符串

说明:

该注解可以写在类上或者方法上
写在类上就是该类下的所有方法都有@ReponseBody功能
当方法上有@ReponseBody注解后
- 方法的返回值为字符串，会将其作为文本内容直接响应给前端
- 方法的返回值为对象，会将对象转换成JSON响应给前端

此处又使用到了类型转换，内部还是通过Converter接口的实现类完成的，所以Converter除了前面所说的功能外，它还可以实现:

对象转Json数据(POJO -> json)
集合转Json数据(Collection -> json)

Rest

简介

REST（Representational State Transfer），表现形式状态转换

当我们想表示一个网络资源的时候，可以使用两种方式:

传统风格资源描述形式
- http://localhost/user/getById?id=1 查询id为1的用户信息
- http://localhost/user/saveUser 保存用户信息
REST风格描述形式
- http://localhost/user/1
- http://localhost/user

优点：
- 隐藏资源的访问行为，无法通过地址得知对资源是何种操作
- 书写简化

按照REST风格访问资源时使用==行为动作==区分对资源进行了何种操作
- http://localhost/users 查询全部用户信息 GET（查询）
- http://localhost/users/1 查询指定用户信息 GET（查询）
- http://localhost/users 添加用户信息 POST（新增/保存）
- http://localhost/users 修改用户信息 PUT（修改/更新）
- http://localhost/users/1 删除用户信息 DELETE（删除）
根据REST风格对资源进行访问称为RESTful

请求的方式比较多，但是比较常用的就4种，分别是GET,POST,PUT,DELETE。

按照不同的请求方式代表不同的操作类型。

发送GET请求是用来做查询
发送POST请求是用来做新增
发送PUT请求是用来做修改
发送DELETE请求是用来做删除

注意事项：
上述行为是约定方式，约定不是规范，可以打破，所以称REST风格，而不是REST规范
描述模块的名字通常使用负数，也就是可以加s的格式描述，表示此类资源，而非单个资源，例如：users、books、account......

入门案例

(2)如果有多个参数需要传递该如何编写?

前端发送请求的时候使用:http://localhost/users/1/tom,路径中的1和tom就是我们想要传递的两个参数。

后端获取参数，需要做如下修改:

@Controller
public class UserController {
    //设置当前请求方法为DELETE，表示REST风格中的删除操作
	@RequestMapping(value = "/users/{id}/{name}",method = RequestMethod.DELETE)
    @ResponseBody
    public String delete(@PathVariable Integer id,@PathVariable String name) {
        System.out.println("user delete..." + id+","+name);
        return "{'module':'user delete'}";
    }
}

关于接收参数，我们学过三个注解@RequestBody、@RequestParam、@PathVariable,这三个注解之间的区别和应用分别是什么?

区别
- @RequestParam用于接收url地址传参或表单传参
- @RequestBody用于接收json数据
- @PathVariable用于接收路径参数，使用{参数名称}描述路径参数
应用
- 后期开发中，发送请求参数超过1个时，以json格式为主，@RequestBody应用较广
- 如果发送非json格式数据，选用@RequestParam接收请求参数
- 采用RESTful进行开发，当参数数量较少时，例如1个，可以采用@PathVariable接收请求路径变量，通常用于传递id值

RESTful快速开发

问题1：每个方法的@RequestMapping注解中都定义了访问路径/books，重复性太高。

问题2：每个方法的@RequestMapping注解中都要使用method属性定义请求方式，重复性太高。

问题3：每个方法响应json都需要加上@ResponseBody注解，重复性太高。

对于刚才的问题，我们都有对应的解决方案：

问题1：每个方法的@RequestMapping注解中都定义了访问路径/books，重复性太高。

将@RequestMapping提到类上面，用来定义所有方法共同的访问路径。

问题2：每个方法的@RequestMapping注解中都要使用method属性定义请求方式，重复性太高。

使用@GetMapping  @PostMapping  @PutMapping  @DeleteMapping代替

问题3：每个方法响应json都需要加上@ResponseBody注解，重复性太高。

1.将ResponseBody提到类上面，让所有的方法都有@ResponseBody的功能
2.使用@RestController注解替换@Controller与@ResponseBody注解，简化书写

知识点1：@RestController

名称	@RestController
类型	==类注解==
位置	基于SpringMVC的RESTful开发控制器类定义上方
作用	设置当前控制器类为RESTful风格，等同于@Controller与@ResponseBody两个注解组合功能

知识点2：@GetMapping @PostMapping @PutMapping @DeleteMapping

名称	@GetMapping @PostMapping @PutMapping @DeleteMapping
类型	==方法注解==
位置	基于SpringMVC的RESTful开发控制器方法定义上方
作用	设置当前控制器方法请求访问路径与请求动作，每种对应一个请求动作，例如@GetMapping对应GET请求
相关属性	value（默认）：请求访问路径

案例：基于RESTful页面数据交互

编写Controller类并使用RESTful进行配置

@RestController
@RequestMapping("/books")
public class BookController {

    @PostMapping
    public String save(@RequestBody Book book){
        System.out.println("book save ==> "+ book);
        return "{'module':'book save success'}";
    }

 	@GetMapping
    public List<Book> getAll(){
        System.out.println("book getAll is running ...");
        List<Book> bookList = new ArrayList<Book>();

        Book book1 = new Book();
        book1.setType("计算机");
        book1.setName("SpringMVC入门教程");
        book1.setDescription("小试牛刀");
        bookList.add(book1);

        Book book2 = new Book();
        book2.setType("计算机");
        book2.setName("SpringMVC实战教程");
        book2.setDescription("一代宗师");
        bookList.add(book2);


        return bookList;
    }

}

SpringMVC需要将静态资源进行放行。

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    //设置静态资源访问过滤，当前类需要设置为配置类，并被扫描加载
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问/pages/????时候，从/pages目录下查找内容
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

该配置类是在config目录下，SpringMVC扫描的是controller包，所以该配置类还未生效，要想生效需要将SpringMvcConfig配置类进行修改

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig {
}

或者

@Configuration
@ComponentScan("com.itheima")
@EnableWebMvc
public class SpringMvcConfig {
}

SSM整合

1.创建工程

2.SSM整合

Spring
- SpringConfig
MyBatis
- MybatisConfig
- JdbcConfig
- jdbc.properties
SpringMVC
- ServletConfig
- SpirngMvcConfig

3.功能模块

表与实现类
dao(接口+自动代理)
service(接口+实现类)
- 业务层接口测试(整合JUnit)
controller
- 表现层接口测试(PostMan)

异常处理器

出现异常现象的常见位置与常见诱因如下：
- 框架内部抛出的异常：因使用不合规导致
- 数据层抛出的异常：因外部服务器故障导致（例如：服务器访问超时）
- 业务层抛出的异常：因业务逻辑书写失败导致（例如：遍历业务书写操作，导致索引异常等）
- 表现层抛出的异常：因数据收集、校验等规则导致（例如：不匹配的数据类型间导致异常）
- 工具类抛出的异常：因工具类书写不严谨不够健壮导致（例如：必要释放的连接长期未释放导致等）
所有异常均抛出到表现层处理
对于上面这些问题及解决方案，SpringMVC已经为我们提供了一套解决方案:
- 对于上面这些问题及解决方案，SpringMVC已经为我们提供了一套解决方案:
  - 异常处理器:
    - 集中的、统一的处理项目中出现的异常。
```
@RestControllerAdvice
public class ProjectExceptionAdvice {
    @ExceptionHandler(Exception.class)
    public void doException(Exception ex){
        System.out.println("出现异常了");
    }
}
```

知识点1：@RestControllerAdvice

名称	@RestControllerAdvice
类型	==类注解==
位置	Rest风格开发的控制器增强类定义上方
作用	为Rest风格开发的控制器类做增强

**说明:**此注解自带@ResponseBody注解与@Component注解，具备对应的功能

知识点2：@ExceptionHandler

名称	@ExceptionHandler
类型	==方法注解==
位置	专用于异常处理的控制器方法上方
作用	设置指定异常的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行,并转入当前方法执行

说明：此类方法可以根据处理的异常不同，制作多个方法分别处理对应的异常

项目异常分类及处理

项目异常分类

业务异常（BusinessException）
- 规范的用户行为产生的异常
  - 用户在页面输入内容的时候未按照指定格式进行数据填写，如在年龄框输入的是字符串
- 不规范的用户行为操作产生的异常
  - 如用户故意传递错误数据
系统异常（SystemException）
- 项目运行过程中可预计但无法避免的异常
  - 比如数据库或服务器宕机
其他异常（Exception）
- 编程人员未预期到的异常，如:用到的文件不存在

处理方案

业务异常（BusinessException）
- 发送对应消息传递给用户，提醒规范操作
  - 大家常见的就是提示用户名已存在或密码格式不正确等
系统异常（SystemException）
- 发送固定消息传递给用户，安抚用户
  - 系统繁忙，请稍后再试
  - 系统正在维护升级，请稍后再试
  - 系统出问题，请联系系统管理员等
- 发送特定消息给运维人员，提醒维护
  - 可以发送短信、邮箱或者是公司内部通信软件
- 记录日志
  - 发消息和记录日志对用户来说是不可见的，属于后台程序
其他异常（Exception）
- 发送固定消息传递给用户，安抚用户
- 发送特定消息给编程人员，提醒维护（纳入预期范围内）
  - 一般是程序没有考虑全，比如未做非空校验等
- 记录日志

拦截器

拦截器是一种动态拦截方法调用的机制，在SpirngMVC中动态拦截控制器方法的执行
作用：
- 在指定的方法调用前后执行预先设定的代码
- 阻止原始方法的执行

拦截器和过滤器区别

归属不同：Filter输入Servlet技术，Interceptor呼入SpringMVC技术
拦截内容不同：Filter对所有访问进行增强，Interceptor仅针对SpringMVC的访问进行增强

拦截器入门案例

创建拦截器类

让类实现HandlerInterceptor接口，重写接口中的三个方法

@Component
//定义拦截器类，实现HandlerInterceptor接口
//注意当前类必须受Spring容器控制
public class ProjectInterceptor implements HandlerInterceptor {
    @Override
    //原始方法调用前执行的内容
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle...");
        return true;
    }

    @Override
    //原始方法调用后执行的内容
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle...");
    }

    @Override
    //原始方法调用完成后执行的内容
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("afterCompletion...");
    }
}

配置拦截器类

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
    }

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        //配置拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books" );
    }
}

SpringMVC添加SpringMvcSupport包扫描

@Configuration
@ComponentScan({"com.itheima.controller","com.itheima.config"})
@EnableWebMvc
public class SpringMvcConfig{
   
}

简化SpringMvcSupport的编写

@Configuration
@ComponentScan({"com.itheima.controller"})
@EnableWebMvc
//实现WebMvcConfigurer接口可以简化开发，但具有一定的侵入性
public class SpringMvcConfig implements WebMvcConfigurer {
    @Autowired
    private ProjectInterceptor projectInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //配置多拦截器
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");
    }
}

拦截器中的preHandler方法，如果返回true,则代表放行，会执行原始Controller类中要请求的方法，如果返回false，则代表拦截，后面的就不会再执行了。

当有拦截器后，请求会先进入preHandle方法，

如果方法返回true，则放行继续执行后面的handle[controller的方法]和后面的方法

如果返回false，则直接跳过后面方法的执行。

多拦截器执行顺序

SpringBoot

SpringBoot简介

SpringBoot设计目的是用来简化Spring应用的初始搭建以及开发过程

原始 Spring 环境搭建和开发存在以下问题：

配置繁琐
依赖设置繁琐

SpringBoot 程序优点恰巧就是针对 Spring 的缺点

自动配置。这个是用来解决 Spring 程序配置繁琐的问题
起步依赖。这个是用来解决 Spring 程序依赖设置繁琐的问题
辅助功能（内置服务器,…）。我们在启动 SpringBoot 程序时既没有使用本地的 tomcat 也没有使用 tomcat 插件，而是使用 SpringBoot 内置的服务器。

创建SpringBoot项目流程

创建新模块

点击 + 选择 New Module 创建新模块

选择 Spring Initializr ，用来创建 SpringBoot 工程

以前我们选择的是 Maven ，今天选择 Spring Initializr 来快速构建 SpringBoot 工程。而在 Module SDK 这一项选择我们安装的 JDK 版本。

对 SpringBoot 工程进行相关的设置

我们使用这种方式构建的 SpringBoot 工程其实也是 Maven 工程，而该方式只是一种快速构建的方式而已。

==注意：打包方式这里需要设置为 Jar==
选中 Web，然后勾选 Spring Web

由于我们需要开发一个 web 程序，使用到了 SpringMVC 技术，所以按照下图红框进行勾选

下图界面不需要任何修改，直接点击 Finish 完成 SpringBoot 工程的构建

创建 Controller

@RestController
@RequestMapping("/books")
public class BookController {

    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("id ==> "+id);
        return "hello , spring boot!";
    }
}

启动服务器

运行Application类

进行测试

用Postman发送请求

也可以选择去官网https://spring.io/projects/spring-boot创建项目

Spirng项目快速启动

1.所以我们只需要使用 Maven 的 package 指令打包就会在 target 目录下生成对应的 Jar 包。

2.进入 jar 包所在位置，在 命令提示符 中输入如下命令

jar -jar springboot_01_quickstart-0.0.1-SNAPSHOT.jar

切换web服务器

我们启动工程默认是tomcat服务器，那能不能不使用 tomcat 而使用 jetty 服务器?而要切换 web 服务器就需要将默认的 tomcat 服务器给排除掉，怎么排除呢？使用 exclusion 标签

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <groupId>org.springframework.boot</groupId>
        </exclusion>
    </exclusions>
</dependency>

添加jetty服务器

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>

基础配置

配置文件格式

SpringBoot提供了多种属性配置方式
- application.properties
```
server.port=80
```
- application.yml
```
server:
  port: 81
```
- application.yaml
```
server:
  port: 82
```
SpringBoot配置文件加载顺序
- application.properties > application.yml > application.yaml

yaml

YAML 一种数据序列化格式
优点：
- 容易阅读
- 容易与脚本语言交互
- 以数据为核心，重数据轻格式
YAML文件扩展名
- .yml(主流)
- .yaml

yaml语法规则

书写yaml文件应该严格遵守yaml语法规则，不然文件将不会被识别导致问题

大小写敏感
属性层级关系使用多行描述，每行结尾使用冒号结束
使用缩进表示层级关系，同层级左侧对齐，只允许使用空格（不允许使用Tab建）
属性值前面添加空格（属性名与属性值之间使用冒号+空格作为分隔）
# 表示注释

yaml数据读取方式

在进行自定义对象封装数据被警告时，将依赖加入pom文件中

<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
	<optional>true</optional>
</dependency>

多环境配置

yml 和 yaml

application.yml 配置文件内容如下

#设置启用的环境
spring:
  profiles:
    active: dev

---
#开发
spring:
  profiles: dev
server:
  port: 80
---
#生产
spring:
  profiles: pro
server:
  port: 81
---
#测试
spring:
  profiles: test
server:
  port: 82
---

==注意：==

在上面配置中给不同配置起名字的 spring.profiles 配置项已经过时。最新用来起名字的配置项是

#开发
spring:
  config:
    activate:
      on-profile: dev

properties文件

properties 类型的配置文件配置多环境需要定义不同的配置文件

application-dev.properties 是开发环境的配置文件。我们在该文件中配置端口号为 80
```
server.port=80
```
application-test.properties 是测试环境的配置文件。我们在该文件中配置端口号为 81
```
server.port=81
```
application-pro.properties 是生产环境的配置文件。我们在该文件中配置端口号为 82
```
server.port=82
```

SpringBoot 只会默认加载名为 application.properties 的配置文件，所以需要在 application.properties 配置文件中设置启用哪个配置文件，配置如下:

spring.profiles.active=pro

命令行启动参数设置

使用 SpringBoot 开发的程序以后都是打成 jar 包，通过 java -jar xxx.jar 的方式启动服务的。那么就存在一个问题，如何切换环境呢？因为配置文件打到的jar包中了。

我们知道 jar 包其实就是一个压缩包，可以解压缩，然后修改配置，最后再打成jar包就可以了。这种方式显然有点麻烦，而 SpringBoot 提供了在运行 jar 时设置开启指定的环境的方式，如下

java –jar xxx.jar –-spring.profiles.active=test

那么这种方式能不能临时修改端口号呢？也是可以的，可以通过如下方式

java –jar xxx.jar –-server.port=88

当然也可以同时设置多个配置，比如即指定启用哪个环境配置，又临时指定端口，如下

java –jar springboot.jar –-server.port=88 –-spring.profiles.active=test

大家进行测试后就会发现命令行设置的端口号优先级高（也就是使用的是命令行设置的端口号），配置的优先级其实 SpringBoot 官网已经进行了说明，参见 :

https://docs.spring.io/spring-boot/docs/current/reference/html/spring-boot-features.html#boot-features-external-config

配置文件分类

有这样的场景，我们开发完毕后需要测试人员进行测试，由于测试环境和开发环境的很多配置都不相同，所以测试人员在运行我们的工程时需要临时修改很多配置，如下

java –jar springboot.jar –-spring.profiles.active=test --server.port=85 --server.servlet.context-path=/heima --server.tomcat.connection-timeout=-1 …… …… …… …… ……

针对这种情况，SpringBoot 定义了配置文件不同的放置的位置；而放在不同位置的优先级时不同的。

SpringBoot 中4级配置文件放置位置：

1级：classpath：application.yml
2级：classpath：config/application.yml
3级：file ：application.yml
4级：file ：config/application.yml

作用：

1级与2级留作系统打包后设置通用属性
3级与4级用于系统开发阶段设置通用属性

SpringBoot整合junit

回顾 Spring 整合 junit

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class UserServiceTest {
    
    @Autowired
    private BookService bookService;
    
    @Test
    public void testSave(){
        bookService.save();
    }
}

使用 @RunWith 注解指定运行器，使用 @ContextConfiguration 注解来指定配置类或者配置文件。而 SpringBoot 整合 junit 特别简单，分为以下三步完成

在测试类上添加 SpringBootTest 注解
使用 @Autowired 注入要测试的资源
定义测试方法进行测试

SpringBoot整合junit

@SpringBootTest
class Springboot07TestApplicationTests {

    @Autowired
    private BookService bookService;

    @Test
    public void save() {
        bookService.save();
    }
}

==注意：==这里的引导类所在包必须是测试类所在包及其子包。

SpringBoot整合Mybatis

回顾Spring整合Mybatis

Spring 整合 Mybatis 需要定义很多配置类

SpringConfig 配置类

导入 JdbcConfig 配置类

导入 MybatisConfig 配置类

@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MyBatisConfig.class})
public class SpringConfig {
}

JdbcConfig 配置类

定义数据源（加载properties配置项：driver、url、username、password）

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public DataSource getDataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

MybatisConfig 配置类

定义 SqlSessionFactoryBean

定义映射配置

@Bean
public MapperScannerConfigurer getMapperScannerConfigurer(){
    MapperScannerConfigurer msc = new MapperScannerConfigurer();
    msc.setBasePackage("com.itheima.dao");
    return msc;
}

@Bean
public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource){
    SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
    ssfb.setTypeAliasesPackage("com.itheima.domain");
    ssfb.setDataSource(dataSource);
    return ssfb;
}

SpringBoot整合Mybatis

创建新模块，选择Spirng初始化，并配置模块相关基础信息

选择当前模块需要使用的技术集(MyBatis Mysql)
在配置文件中（application.yaml）设置数据源参数

注意事项

SpirngBoot版本低于2.4.3，Mysql驱动版本大于8时，需要在url连接串中配置时区
jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
或在MySql数据库配置时区解决此问题

定义数据层接口与映射配置

@Mapper
public interface BookDao {
    @Select("select * from tbl_book where id = #{id}")
    public Book getById(Integer id);
}

测试类中注入dao接口，测试功能

@SpringBootTest
class Spring08MybatisApplicationTests {
    @Autowired
    private BookDao bookDao;
    @Test
    void testGetById() {
        Book book = bookDao.getById(2);
        System.out.println(book);
    }
}

SpringBoot整合ssm

pom.xml

配置起步依赖，必要的资源坐标
aplication.yml

设置数据源，端口
配置类

全部删除
dao

设置@Mapper
测试类
页面

放置在resources目录下的static目录中

MyBatis Plus

MyBatisPlus入门案例与简介

入门案例

创建新模块，选择Spring初始化，并配置模块相关基础信息
选择当前模块需要使用的技术集（仅保留JDBC）

手动添加MyBatisPlus起步依赖

<dependency>
	<groupId>com.baomidou</groupId>
	<artifactId>mybatis-plus-boot-starter</artifactId>	
    <version>3.4.1</version>
</dependency>

由于MyBatisPlus并未被收录到idea的系统内置配置，无法直接选择加入

设置Jdbc参数(application.yml)

spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db
    username: 
    password:

使用druid数据源，需要导入对应坐标

制作实体类与表结构（类名与表名对应，属性名与字段名对应）如类名与表名不对应可在实体类上方添加注释@TableName("表名")

定义数据接口，继承BaseMapper<实体类类名>

@Mapper
public interface BookDao extends BaseMapper<Book> {
}

测试类中注入dao接口，测试功能

@SpringBootTest
class Mybatisplus001QuickstartApplicationTests {

    @Autowired
    private BookDao bookDao;

    @Test
    void test() {
        List<Book> books = bookDao.selectList(null);
        System.out.println(books);
    }

}

Mybatis简介

MP是基于Mybatis框架基础上开发的增强型工具，旨在简化开发，提升效率
开发方式
- 基于MyBatis使用MyBatisPlus
- 基于Spring使用MyBatisPlus
- 基于SpringBoot使用MyBatisPlus
MyBatisPlus的官网为:https://mp.baomidou.com/

MyBatisPlus的特性:

无侵入：只做增强不做改变，不会对现有工程产生影响
强大的 CRUD 操作：内置通用 Mapper，少量配置即可实现单表CRUD 操作
支持 Lambda：编写查询条件无需担心字段写错
支持主键自动生成
内置分页插件
……

标准数据层开发

标准CRUD使用

新增

在进行新增之前，我们可以分析下新增的方法:

int insert (T t)

T:泛型，新增用来保存新增数据
int:返回值，新增成功后返回1，没有新增成功返回的是0

在测试类中进行新增操作:

@Test
void testSave(){
    Book book = new Book();
    book.setId(1);
    book.setType("市场营销");
    book.setName("零基础学python（全彩版）");
    book.setDescription("黑马程序员，帮你成为python语言黑马");
    bookDao.insert(book);
}

删除

int deleteById (Serializable id)

Serializable：参数类型

思考:参数类型为什么是一个序列化类?
从这张图可以看出，
- String和Number是Serializable的子类，
- Number又是Float,Double,Integer等类的父类，
- 能作为主键的数据类型都已经是Serializable的子类，
- MP使用Serializable作为参数类型，就好比我们可以用Object接收任何数据类型一样。
int:返回值类型，数据删除成功返回1，未删除数据返回0。

在测试类中进行新增操作:

 @SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testDelete() {
        userDao.deleteById(1401856123725713409L);
    }
}

修改

int updateById(T t);

T:泛型，需要修改的数据内容，注意因为是根据ID进行修改，所以传入的对象中需要有ID属性值
int:返回值，修改成功后返回1，未修改数据返回0

在测试类中进行新增操作:

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;

    @Test
    void testUpdate() {
        User user = new User();
        user.setId(1L);
        user.setName("Tom888");
        user.setPassword("tom888");
        userDao.updateById(user);
    }
}

**说明:**修改的时候，只修改实体对象中有值的字段。

根据ID查询

T selectById (Serializable id)

Serializable：参数类型,主键ID的值
T:根据ID查询只会返回一条数据

在测试类中进行新增操作:

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetById() {
        User user = userDao.selectById(2L);
        System.out.println(user);
    }
}

查询所有

在进行查询所有之前，我们可以分析下查询所有的方法:

List<T> selectList(Wrapper<T> queryWrapper)

Wrapper：用来构建条件查询的条件，目前我们没有可直接传为Null
List:因为查询的是所有，所以返回的数据是一个集合

在测试类中进行新增操作:

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;
    
    @Test
    void testGetAll() {
        List<User> userList = userDao.selectList(null);
        System.out.println(userList);
    }
}

Lombok

概念

Lombok，一个Java类库，提供了一组注解，简化POJO实体类开发。

使用步骤

步骤1:添加lombok依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <!--<version>1.18.12</version>-->
</dependency>

注意：版本可以不用写，因为SpringBoot中已经管理了lombok的版本。

步骤2:安装Lombok的插件

==新版本IDEA已经内置了该插件，如果删除setter和getter方法程序有报红，则需要安装插件==

如果在IDEA中找不到lombok插件，可以访问如下网站

https://plugins.jetbrains.com/plugin/6317-lombok/versions

根据自己IDEA的版本下载对应的lombok插件，下载成功后，在IDEA中采用离线安装的方式进行安装。

步骤3:模型类上添加注解

Lombok常见的注解有:

@Setter:为模型类的属性提供setter方法
@Getter:为模型类的属性提供getter方法
@ToString:为模型类的属性提供toString方法
@EqualsAndHashCode:为模型类的属性提供equals和hashcode方法
==@Data:是个组合注解，包含上面的注解的功能==
==@NoArgsConstructor:提供一个无参构造函数==
==@AllArgsConstructor:提供一个包含所有参数的构造函数==

Lombok的注解还有很多，上面标红的三个是比较常用的，其他的大家后期用到了，再去补充学习。

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;
}

说明:

Lombok只是简化模型类的编写，我们之前的方法也能用，比如有人会问:我如果只想要有name和password的构造函数，该如何编写?

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Long id;
    private String name;
    private String password;
    private Integer age;
    private String tel;

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }
}

这种方式是被允许的。

分页功能

IPage<T> selectPage(IPage<T> page, Wrapper<T> queryWrapper)

IPage:用来构建分页查询条件
Wrapper：用来构建条件查询的条件，目前我们没有可直接为Null
IPage:返回值，你会发现构建分页条件和方法的返回值都是IPage

IPage是一个接口，我们需要找到它的实现类来构建它，具体的实现类，可以进入到IPage类中按ctrl+h,会找到其有一个实现类为Page。

步骤1:调用方法传入参数获取返回值

@SpringBootTest
class Mybatisplus01QuickstartApplicationTests {

    @Autowired
    private UserDao userDao;
    
    //分页查询
    @Test
    void testSelectPage(){
        //1 创建IPage分页对象,设置分页参数,1为当前页码，3为每页显示的记录数
        IPage<User> page=new Page<>(1,3);
        //2 执行分页查询
        userDao.selectPage(page,null);
        //3 获取分页结果
        System.out.println("当前页码值："+page.getCurrent());
        System.out.println("每页显示数："+page.getSize());
        System.out.println("一共多少页："+page.getPages());
        System.out.println("一共多少条数据："+page.getTotal());
        System.out.println("数据："+page.getRecords());
    }
}

步骤2:设置分页拦截器

这个拦截器MP已经为我们提供好了，我们只需要将其配置成Spring管理的bean对象即可。

@Configuration
public class MybatisPlusConfig {
    
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor(){
        //1 创建MybatisPlusInterceptor拦截器对象
        MybatisPlusInterceptor mpInterceptor=new MybatisPlusInterceptor();
        //2 添加分页拦截器
        mpInterceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return mpInterceptor;
    }
}

**说明:**上面的代码记不住咋办呢?

这些内容在MP的官方文档中有详细的说明，我们可以查看官方文档类配置

步骤3:运行测试程序

如果想查看MP执行的SQL语句，可以修改application.yml配置文件，

mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl #打印SQL日志到控制台

打开日志后，就可以在控制台打印出对应的SQL语句，开启日志功能性能就会受到影响，调试完后记得关闭。

DQL编程控制

条件查询

多条件查询格式

需要：查询年龄大于等于18，小于65岁的用户

格式一：常规格式

QueryWrapper<User> qw = new QueryWrapper<User>();
qw.lt("age",65);
qw.ge("age",18);
List<User> userList = userDao.selectList(qw);
Systeam.out.println(userList);

格式二：链式编程格式

QueryWrapper<User> qw = new QueryWrapper<User>();
qw.lt("age",65).ge("age",18);
List<User> userList = userDao.selectList(qw);
Systeam.out.println(userList);

格式三：lambda格式(推荐)

QueryWrapper<User> qw = new QueryWrapper<User>();
        qw.lambda().lt(User::getAge, 65).ge(User::getAge,18);//添加条件
        List<User> userList = userDao.selectList(qw);
        System.out.println(userList);

格式四：lambda格式(推荐)

LambdaQueryWrapper<User> qw = new LambdaQueryWrapper<User>();
        qw.lt(User::getAge, 65).ge(User::getAge,18);//添加条件
        List<User> userList = userDao.selectList(qw);
        System.out.println(userList);

并且(and)

LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
lqw.lt(User::getAge, 30).gt(User::getAge, 10);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

或者(or)

LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
lqw.lt(User::getAge, 30).or().gt(User::getAge, 10);
List<User> userList = userDao.selectList(lqw);
System.out.println(userList);

关于null的判定

如果传入的某一个查询条件为空，则查询会失败。

我们选择lt(boolean condition, R column, Object val)方法

true，则添加条件，返回false则不添加条件

因此，如果某一查询条件为空时，我们返回false。

@Test
   void testGetAll(){
       //模拟页面传递过来的查询数据
       UserQuery uq = new UserQuery();
       uq.setAge(10);
       uq.setAge2(30);
       LambdaQueryWrapper<User> lqw = new LambdaQueryWrapper<User>();
       lqw.lt(null!=uq.getAge2(),User::getAge, uq.getAge2());
       lqw.gt(null!=uq.getAge(),User::getAge, uq.getAge());
       List<User> userList = userDao.selectList(lqw);
       System.out.println(userList);
   }

查询投影

查询结果包含模型类中的部分属性

查询条件

更多查询条件设置参看https://mybatis.plus/guide/wrapper.html#abstractwrapper

映射匹配兼容性

DML编程控制

id生成策略控制

不同的表应用不同的id生成策略

日志：自增（1,2,3,4，……）
购物订单：特殊规则（FQ23948AK3843）
外卖单：关联地区日期等信息（10 04 20200314 34 91）
关系表：可省略id
……

名称	@TableId
类型	==属性注解==
位置	模型类中用于表示主键的属性定义上方
作用	设置当前类中主键属性的生成策略
相关属性	value(默认)：设置数据库表主键名称 type:设置主键属性的生成策略，值查照IdType的枚举值

@Data
@TableName("tbl_user")
public class User {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
}

能不能在某一处进行配置，就能让所有的模型类都可以使用该主键ID策略呢?

答案是肯定有，我们只需要在配置文件中添加如下内容:

mybatis-plus:
  global-config:
    db-config:
    	id-type: assign_id

配置完成后，每个模型类的主键ID策略都将成为assign_id.

数据库表与模型类的映射关系

MP会默认将模型类的类名名首字母小写作为表名使用，假如数据库表的名称都以tbl_开头，那么我们就需要将所有的模型类上添加@TableName

配置起来还是比较繁琐，简化方式为在配置文件中配置如下内容:

mybatis-plus:
  global-config:
    db-config:
    	table-prefix: tbl_

设置表的前缀内容，这样MP就会拿 tbl_加上模型类的首字母小写，就刚好组装成数据库的表名。

多记录操作

具体该如何实现多条删除，我们找找对应的API方法

int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

除了按照id集合进行批量删除，也可以按照id集合进行批量查询，还是先来看下API

List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);

逻辑删除

删除操作业务问题：业务数据从数据库中丢弃
逻辑删除：为数据设置是否可用状态字段，删除时设置状态字段为不可用状态，数据保留在数据库中

修改数据库表添加`deleted`列

字段名可以任意，内容也可以自定义，比如0代表正常，1代表删除，可以在添加列的同时设置其默认值为0正常。

实体类添加属性

(1)添加与数据库表的列对应的一个属性名，名称可以任意，如果和数据表列名对不上，可以使用@TableField进行关系映射，如果一致，则会自动对应。

(2)标识新增的字段为逻辑删除字段，使用@TableLogic

@Data
//@TableName("tbl_user") 可以不写是因为配置了全局配置
public class User {
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
    @TableLogic(value="0",delval="1")
    //value为正常数据的值，delval为删除数据的值
    private Integer deleted;
}

运行删除方法

@SpringBootTest
class Mybatisplus03DqlApplicationTests {

    @Autowired
    private UserDao userDao;
	
    @Test
    void testDelete(){
       userDao.deleteById(1L);
    }
}

MP的逻辑删除会将所有的查询都添加一个未被删除的条件，也就是已经被删除的数据是不应该被查询出来的。

如果每个表都要有逻辑删除，那么就需要在每个模型类的属性上添加@TableLogic注解，如何优化?

在配置文件中添加全局配置，如下:

mybatis-plus:
  global-config:
    db-config:
      # 逻辑删除字段名
      logic-delete-field: deleted
      # 逻辑删除字面值：未删除为0
      logic-not-delete-value: 0
      # 逻辑删除字面值：删除为1
      logic-delete-value: 1

逻辑删除本质

逻辑删除的本质其实是修改操作。如果加了逻辑删除字段，查询数据时也会自动带上逻辑删除字段。

执行的SQL语句为:

UPDATE tbl_user SET ==deleted===1 where id = ? AND ==deleted===0

乐观锁

业务并发现象带来的问题：秒杀

步骤1:数据库表添加列

列名可以任意，比如使用version,给列设置默认值为1

步骤2:在模型类中添加对应的属性

根据添加的字段列名，在模型类中添加对应的属性值

@Data
//@TableName("tbl_user") 可以不写是因为配置了全局配置
public class User {
    @TableId(type = IdType.ASSIGN_UUID)
    private String id;
    private String name;
    @TableField(value="pwd",select=false)
    private String password;
    private Integer age;
    private String tel;
    @TableField(exist=false)
    private Integer online;
    private Integer deleted;
    @Version
    private Integer version;
}

步骤3:添加乐观锁的拦截器

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor mpInterceptor() {
        //1.定义Mp拦截器
        MybatisPlusInterceptor mpInterceptor = new MybatisPlusInterceptor();
        //2.添加乐观锁拦截器
        mpInterceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
        return mpInterceptor;
    }
}

步骤4:执行更新操作

@SpringBootTest
class Mybatisplus03DqlApplicationTests {

    @Autowired
    private UserDao userDao;
	
    @Test
    void testUpdate(){
       User user = new User();
        user.setId(3L);
        user.setName("Jock666");
        user.setVersion(1);
        userDao.updateById(user);
    }
}

代码生成器

模板: MyBatisPlus提供，可以自己提供，但是麻烦，不建议
数据库相关配置:读取数据库获取表和字段信息
开发者自定义配置:手工配置，比如ID生成策略

步骤：

添加依赖

<!--代码生成器-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.4.1</version>
</dependency>

<!--velocity模板引擎-->
<dependency>
<groupId>org.apache.velocity</groupId>
<artifactId>velocity-engine-core</artifactId>
<version>2.3</version>
</dependency>

创建代码生成类

public class CodeGenerator {
    public static void main(String[] args) {
        //1.获取代码生成器的对象
        AutoGenerator autoGenerator = new AutoGenerator();

        //设置数据库相关配置
        DataSourceConfig dataSource = new DataSourceConfig();
        dataSource.setDriverName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mybatisplus_db?serverTimezone=UTC");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        autoGenerator.setDataSource(dataSource);

        //设置全局配置
        GlobalConfig globalConfig = new GlobalConfig();
        globalConfig.setOutputDir(System.getProperty("user.dir")+"/mybatisplus_04_generator/src/main/java");    //设置代码生成位置
        globalConfig.setOpen(false);    //设置生成完毕后是否打开生成代码所在的目录
        globalConfig.setAuthor("黑马程序员");    //设置作者
        globalConfig.setFileOverride(true);     //设置是否覆盖原始生成的文件
        globalConfig.setMapperName("%sDao");    //设置数据层接口名，%s为占位符，指代模块名称
        globalConfig.setIdType(IdType.ASSIGN_ID);   //设置Id生成策略
        autoGenerator.setGlobalConfig(globalConfig);

        //设置包名相关配置
        PackageConfig packageInfo = new PackageConfig();
        packageInfo.setParent("com.aaa");   //设置生成的包名，与代码所在位置不冲突，二者叠加组成完整路径
        packageInfo.setEntity("domain");    //设置实体类包名
        packageInfo.setMapper("dao");   //设置数据层包名
        autoGenerator.setPackageInfo(packageInfo);

        //策略设置
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig.setInclude("tbl_user");  //设置当前参与生成的表名，参数为可变参数
        strategyConfig.setTablePrefix("tbl_");  //设置数据库表的前缀名称，模块名 = 数据库表名 - 前缀名  例如： User = tbl_user - tbl_
        strategyConfig.setRestControllerStyle(true);    //设置是否启用Rest风格
        strategyConfig.setVersionFieldName("version");  //设置乐观锁字段名
        strategyConfig.setLogicDeleteFieldName("deleted");  //设置逻辑删除字段名
        strategyConfig.setEntityLombokModel(true);  //设置是否启用lombok
        autoGenerator.setStrategy(strategyConfig);
        //2.执行生成操作
        autoGenerator.execute();
    }
}

对于代码生成器中的代码内容，我们可以直接从官方文档中获取代码进行修改

https://mp.baomidou.com/guide/generator.html

Hexo

Spring

学习路线

核心容器的核心概念

IoC入门案例思路分析

DI入门案例

bean基础配置

别名配置

bean作用范围说明

单例bean与原型bean的区别

bean实例化的三种方式

构造方法（常用）

静态工厂（了解）

实例工厂

FactoryBean（实用）

bean生命周期

bean生命周期

bean销毁时机

依赖注入方式

依赖注入方式选择

自动装配

集合注入

第三方资源配置管理

加载properties文件

容器

创建容器

获取bean

容器类结构层次

BeanFactory

核心容器总结

bean相关

依赖注入相关

注解开发

注解开发定义bean

纯注解开发

注解开发小结

bean作用范围与生命周期管理

依赖注入

加载properties文件

第三方bean

第三方bean管理

第三方bean依赖注入

注解开发总结

XML配置对比注解配置

Spring整合mybatis

Spring整合junit

AOP

AOP核心概念

AOP入门案例思路分析

步骤

AOP工作流程

AOP切入点表达式

书写技巧

AOP通知类型

案例：测量业务层接口执行效率

AOP通知获取数据

AOP总结

事务

案例：银行账户转账

Spring事务角色

事务相关配置

案例：转账业务追加日志

事务传播行为

SpringMVC

SpringMVC入门案例

入门案例工作流程分析

bean加载控制

请求与响应

请求映射路径

请求参数

日期类型参数传递

类型转换器

json数据

接受请求中json数据

Rest

简介

入门案例

RESTful快速开发

知识点1：@RestController

知识点2：@GetMapping @PostMapping @PutMapping @DeleteMapping

修改数据库表添加`deleted`列