SSM+Maven高级+MybatisPlus万字笔记-阿里云开发者社区

SSM框架学习

前言：花了一周学习了SSM(Spring+SpringMVC+Mybatis)以及Maven高级部分加MybatisPlus并且做了这个笔记，自己看黑马视频做的总结，不得不说学习还得多做笔记，做完笔记后还得在回头回忆一遍，遇到没记住的部分可以回来翻阅，很方便。仅上传作纪念，之前看JavaWeb也有记笔记，到时候有时间再放上来，仅供参考，有做的不好的地方还请多多指教！

一：Spring Framework系统框架

二：Spring核心概念

1.IoC、Bean、DI

1.1：IoC&Bean

IoC(Inversion of Control)控制反转

使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权转移到外部，此思想称为控制反转。
Spring提供了一个容器，称为IoC容器，用来充当IoC思想中的"外部"
IoC容器负责对象的创建、初始化等一系列工作，被创建的对象在IoC容器中被称为Bean。

1.2：DI

DI(Dependency Injection)依赖注入

在容器中建立Bean与Bean之间的依赖关系的整个过程，称为依赖注入。

1.3：最终效果

充分解耦
使用IoC容器管理Bean
在IoC容器内将有依赖关系的Bean进行关系绑定(ID)
使用对象时不仅可以直接从IoC容器中获取，并且获取到的Bean已经绑定了所有的依赖关系。

2.快速入门

2.1：导入相关坐标

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

2.2：定义Spring管理的类(接口)

public interface BookDao {
    public void save();
}
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}
public interface BookService {
    public void save();
}
public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new的方式创建的dao对象
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //6.提供对应的set方法(容器在执行)
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

2.3：创建Spring配置文件，配置对应类作为Spring管理的Bean

applicationContext.xml

<!--1.导入spring坐标：spring-context-->
    <!--2.配置bean-->
    <!--id属性表示bean的名字
    class属性表示给bean定义类型
  name属性表示给bean取别名，可以当做id使用-->
    <bean id="bookDao" name="dao bookDaoImpl" class="com.my.dao.impl.BookDaoImpl"/>
    <bean id="bookService" class="com.my.service.impl.BookServiceImpl">
        <!--7.配置server与Dao的关系-->
        <!--name属性表示配置哪一个具体的属性，属性名称
        ref属性表示参照哪一个bean-->
        <property name="bookDao" ref="bookDao"/>
    </bean>

2.4：初始化IoC容器(Spring核心容器/Spring容器)，通过容器获取Bean

public static void main(String[] args) {
    //3.加载配置文件得到上下文对象，也就是容器对象
    ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    //4.获取资源
    // BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    // bookDao.save();
    BookService bookService = (BookService) ctx.getBean("bookService");
    bookService.save();
}

3：bean的作用范围

scope属性用于改变bean的作用范围，默认情况下scope属性为singleton，此时为单例模式，即创建出来的bean都是同一个，当scope属性为prototype时候，即为非单例模式。
为什么bean默认情况下为单例模式？可以用一个bean完成多个功能，提高复用性。
适合交给容器进行管理的bean：

表现层对象(servlet)
业务层对象(service)
数据层对象(Dao)
工具类对象

不适合交给容器进行管理的bean

封装实体的域对象

4：实例化bean的四种方式

4.1：构造方法(常用)

需要提供默认构造方法(无参构造方法)
如果无参构造方法不存在，将抛出异常BeanCreationException

4.2:静态工厂(了解)

静态工厂

public class OrderDaoFactory{
    public static OrderDao getOrderDao(){
        return new OrderDaoImpl();
    }
}

配置

<bean
    id="orderDao"
    class="com.my.factory.OrderDaoFactory"
    factory-method="getOrderDao"
/>

4.3:实例工厂(了解)

4.4：FactoryBean(实用)

BookDaoFactoryBean.java

public class BookDaoFactoryBean implements FactoryBean<BookDao> {
    @Override
    public BookDao getObject() throws Exception {
        return new BookDaoImpl();
    }
    @Override
    public Class<?> getObjectType() {
        return BookDao.class;
    }
}

配置信息

<!--FactoryBean方式-->
<bean id="bookDaoFac" class="com.my.factory.BookDaoFactoryBean"/>

4.5：Bean生命周期

初始化容器

创建对象(内存分配)
执行构造方法
执行属性注入(set操作)
执行bean初始化方法

使用Bean

执行业务操作

关闭/销毁容器

执行bean销毁方法

bean生命周期控制

配置

init-method
destroy-method

接口(了解)

InitializingBean
DisposableBean

关闭容器

ConfigurableApplicationContext

手工关闭容器
ConfigurableApplicationContext接口close()操作
注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机
ConfigurableApplicationContext接口registerShutdownHook()操作

5：向类传递数据

5.1：依赖注入方式

setter注入

简单类型
引用类型

构造器注入

简单类型
引用类型

5.2：setter注入

引用类型

在bean中定义引用数据类型属性并提供可访问的set方法

private UserDao userDao;
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

配置中使用property标签ref属性注入引用类型对象

<bean id="userDao" class="com.my.dao.impl.UserDaoImpl"/>
<bean id="bookService" class="com.my.service.impl.BookServiceImpl">
    <!--name属性表示配置哪一个具体的属性
    ref属性表示参照哪一个bean-->
    <!--注入引用数据类型-->
    <property name="userDao" ref="userDao"/>
</bean>

简单类型

在bean中定义引用类型属性并提供可访问的set方法
BookDaoImpl

public class BookDaoImpl implements BookDao {
    private int conNum;
    private String dbName;
    public void setConNum(int conNum) {
        this.conNum = conNum;
    }
    public void setDbName(String dbName) {
        this.dbName = dbName;
    }
    public void save() {
        System.out.println("book dao save ..."+conNum+" "+dbName);
    }
}

配置中使用property标签value属性注入简单类型数据

<bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">
    <!--注入简单数据类型-->
    <property name="conNum" value="10"/>
    <property name="dbName" value="mysql"/>
</bean>

5.3：构造器注入

引用类型

在bean中定义引用数据类型属性并提供可访问的构造方法

private BookDao bookDao;
private UserDao userDao;
public BookServiceImpl(BookDao bookDao, UserDao userDao) {
    this.bookDao = bookDao;
    this.userDao = userDao;
}

配置中使用constructor-arg标签ref属性注入引用类型对象

<bean id="bookService" class="com.my.service.impl.BookServiceImpl">
    <!--注入引用数据类型-->
    <constructor-arg name="bookDao" ref="bookDao"/>
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

简单类型

在bean中定义简单数据类型属性并提供可访问的构造方法

private int conNum;
private String dbName;
public BookDaoImpl(int conNum, String dbName) {
    this.conNum = conNum;
    this.dbName = dbName;
}

配置中使用constructor-arg标签value属性注入简单类型对象

<bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">
    <constructor-arg name="conNum" value="10"/>
    <constructor-arg name="dbName" value="mysql"/>
</bean>

配置中使用constructor-arg标签type属性设置按照形参类型注入
配置中使用constructor-arg标签index属性设置按照形参位置注入

5.4：依赖注入方式选择

5.5：自动类型的装配

使用bean标签autowire属性设置自动装配的类型(byType、byName(耦合度高，不推荐))

<bean id="bookDao" class="com.my.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.my.service.impl.BookServiceImpl" autowire="byType"/>
<bean id="bookService" class="com.my.service.impl.BookServiceImpl" autowire="byName"/>

依赖自动装配特征
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-y8PTeIUR-1653122017072)(SSM笔记.assets/image-20220515195109170.png)]

5.6：注入集合

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(Arrays.toString(array));
        System.out.println(list);
        System.out.println(set);
        System.out.println(map);
        System.out.println(properties);
    }
}

<bean id="bookDao" class="com.my.dao.impl.BookDaoImpl">
    <property name="array">
        <array>
            <value>100</value>
            <value>200</value>
            <value>300</value>
        </array>
    </property>
    <property name="list">
        <list>
            <value>country</value>
            <value>aaa</value>
            <value>bbb</value>
        </list>
    </property>
    <property name="set">
        <set>
            <value>100</value>
            <value>aaa</value>
            <!--自动去重-->
            <value>aaa</value>
            <value>bbb</value>
        </set>
    </property>
    <property name="map">
        <map>
            <entry key="country" value="china"/>
            <entry key="province" value="guangdong"/>
            <entry key="city" value="shenzhen"/>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="country">china</prop>
            <prop key="province">guangdong</prop>
            <prop key="city">guangzhou</prop>
        </props>
    </property>
</bean>

6：数据源对象管理

6.1：基本配置

6.1.1导入Druid坐标

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

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

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

6.2：加载properties文件

6.2.1.开启context名称空间

<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"  <!--更改1-->
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context  <!--更改2-->
            http://www.springframework.org/schema/context/spring-context.xsd"> <!--更改3-->

6.2.2.使用context命名空间，加载指定properties文件

<context:property-placeholder location="jdbc.properties"/>

6.2.3.使用${}读取加载的属性值

<bean id="dataSource"  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>

6.2.4.其他设置

6.2.5.加载配置文件

6.2.6.容器相关

6.2.7获取bean

6.3：注解开发bean

6.3.1使用@Componet定义bean

@Component("bookDao")
public class BookDaoImpl implements BookDao {
}
@Component
public class BookServiceImpl implements BookService {
}

6.3.2核心配置文件中通过组件扫描加载bean

<!--配置核心文件扫描bean-->
<context:component-scan base-package="com.my"/>

6.3.3 Spring提供@Component注解的三个衍生注解(与Component功能一样)

@Controller  //用于表现层bean定义
@Service  //用于业务层定义bean
@Repository  //用于数据层bean定义

7：纯注解开发:

7.1：基本配置

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

7.1.2：Java类代替Spring核心配置文件

com.my.config.SpringConfig.java

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

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

public static void main(String[] args) {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
    //获取资源 按bean名称获取
    BookDao bookDao = (BookDao) ctx.getBean("bookDao");
    System.out.println(bookDao);
    // 按bean类型获取
    BookService bookService = ctx.getBean(BookService.class);
    System.out.println(bookService);
}

7.1.4：小结

7.2：作用范围及生命周期

7.3：依赖注入

7.3.1：注入引用类型

7.3.2：简单数据类型

@Value("${}")
private String name;

7.3.3：小结

7.4：第三方Bean的注入

7.5：XML配置VS注解配置

8：Spring整合Mybatis

8.1：jdbcConfig

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 dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }

8.2：mybatisConfig

public class mybatisConfig {
    //替换xml基本配置信息
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setTypeAliasesPackage("com.my.pojo");
        sqlSessionFactoryBean.setDataSource(dataSource);
        return sqlSessionFactoryBean;
    }
    //替换
    /*<mappers>
        <package name="com.my.dao"/>
    </mappers>*/
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.my.dao");
        return msc;
    }
}

8.3：SpringConfig

@Configuration
@ComponentScan("com.my")
@PropertySource("classpath:jdbc.properties")
@Import({jdbcConfig.class,mybatisConfig.class})
public class SpringConfig {
}

9：Spring整合Junit

9.1：导入坐标

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.20.RELEASE</version>
</dependency>

9.2：创建junit测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    private AccountService accountService;
    @Test
    public void testFindById(){
        Account ac = accountService.findById(1);
        System.out.println(ac);
    }
    @Test
    public void testFindAll(){
        for (Account account : accountService.findAll()) {
            System.out.println(account);
        }
    }
}

10：AOP(面向切面编程)

10.1：基本概念

AOP(Aspect Oriented Programming)面向切面编程，一种编程规范，指导开发者如何组织程序结构

OOP：面向对象编程

作用：在不惊动原始设计的基础上为其进行功能增强
Spring概念：无侵入式/无入侵式
连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等

在SpringAOP中，理解为方法的执行

切入点(Pointcut)：匹配连接点的式子

在SpringAOP中，一个切入点可以描述一个具体方法，也可以匹配多个方法

一个具体方法：com.my.dao包下的BookDao接口中的无形参无返回值的save()方法
匹配多个方法：所有的save方法，所有以get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法。

通知(Advice)：在切入点处执行的操作，也就是共性功能

在SpringAOP中，功能最终以方法的形式呈现

通知类：定义通知的类
切面(Aspect)：描述通知与切入点的对应关系

10.2：入门案例

10.2.1：导入aop相关坐标

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

10.2.2：实现dao接口与实现类

@Repository
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
    @Override
    public void update() {
        System.out.println("book dao update...");
    }
}

10.2.3：定义通知类，制作通知

10.2.4：定义切入点

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

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

@Component   //6.1 定义通知类受Spring容器管理
@Aspect  //6.2 定义当前类为切面类
public class MyAdvice {
    //4.定义切入点
    @Pointcut("execution(void com.my.dao.BookDao.update())")
    public void pt(){}
    //3.定义通知类
    @Before("pt()")  //5.绑定切入点与通知关系，并指定通知添加到原始连接点的具体执行位置
    public void before(){
        System.out.println(System.currentTimeMillis());
    }
}

10.2.7：开启Spring对Aop注解驱动支持

@Configuration
@ComponentScan("com.my")
@EnableAspectJAutoProxy  //7.开启Spring对Aop注解驱动支持
public class SpringConfig {
}

10.2.8：其他代码

public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }
}

10.3：AOP执行流程

10.4：AOP切入点表达式

10.5：AOP通知

10.5.1：前置通知 @Before

10.5.2：后置通知 @After

10.5.3：环绕通知(重点)

●参数ProceedingJoinPoint参数必须放在第一位。

10.5.4：返回后通知(了解) @AfterReturning 原始切入点方法正常执行完毕后运行

10.5.5：抛出异常通知(了解) @AfterThrowing 抛出异常后执行，不抛异常不执行

10.6：执行效率案例

@Component
@Aspect
public class ProjectAdvice {
    @Pointcut("execution(* com.my.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++) {
            Object ret = pjp.proceed();
        }
        long end = System.currentTimeMillis();
        System.out.println("执行"+className+"."+methodName+"万次耗时"+(end-start)+"ms");
    }
}

10.7：AOP通知获取数据

10.7.1：获取参数

10.7.2：获取返回值

11：Spring事务

11.1：开启事务步骤

11.2：事务角色

11.3：事务配置&传播行为

11.3.1：事务配置

11.3.2：事务传播

11.3.3：案例

在jdbcConfig中添加事务管理器

//设置事务管理器
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
    DataSourceTransactionManager ptm = new DataSourceTransactionManager();
    ptm.setDataSource(dataSource);
    return ptm;
}

在SpringConfig中开启事务支持

@Configuration
@ComponentScan("com.my")
@PropertySource("classpath:jdbc.properties")
@Import({jdbcConfig.class,mybatisConfig.class})
@EnableAspectJAutoProxy   //开启Spring对Aop注解驱动的支持
@EnableTransactionManagement //开启事务支持
public class SpringConfig {
}

Dao层操作

//数据层操作
public interface AccountDao {
    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name")String name,@Param("money")Double money);
    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name,@Param("money") Double money);
}

public interface LogDao {
    @Insert("insert into tbl_log(info,createDate) values(#{info},now())")
    void log(String info);
}

Service层

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

public interface LogService {
    //propagation设置事务属性：传播行为设置为当前操作需要新事务
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    void log(String out,String in,Double money);
}

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    @Autowired
    private LogService logService;
    @Override
    public void transfer(String out, String in, Double money) {
        try{
            accountDao.outMoney(out,money);
            int a = 1/0;
            accountDao.inMoney(in,money);
        }finally {
            logService.log(out,in,money);
        }
    }
}

@Service
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;
    @Override
    public void log(String out, String in, Double money) {
        logDao.log(out+"向"+in+"转账"+money+"钱");
    }
}

Test

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
    @Autowired
    AccountService accountService;
    @Test
    public void transferTest(){
        accountService.transfer("Tom","Jerry",100D);
    }
}

三：SpringMVC

1：概述

SpringMVC是一种基于Java实现MVC模型的轻量级Web框架
优点

使用简单，开发便捷(相比于Servlet)
灵活性强

2：快速入门

2.1：导入坐标

<dependencies>
    <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>
</dependencies>

2.2：初始化SpringMVC环境

@Configuration
@ComponentScan("com.my")   //设定SpringMVC加载对应bean
public class SpringMVCConfig {
}

2.3：创建SpringMVC控制器类(等同于Servlet功能)

@Controller
public class UserController {
    @RequestMapping("/save")  //设置当前控制器方法请求访问路径
    @ResponseBody   //设置当前控制器方法响应内容为当前返回值，无需解析
    public String save(){
        System.out.println("user save...");
        return "{'info':'springmvc'}";
    }
}

2.4：初始化Servlet容器，加载SpringMVC环境，并设置SpringMVC请求拦截的路径

//AbstractDispatcherServletInitializer类是SpringMVC提供的快速初始化Web3.0容器的抽象类
public class ServletContainersInitConfig extends AbstractDispatcherServletInitializer {
    //初始化容器并注册返回容器到Tomcat中，以便可以访问bean
    @Override
    protected WebApplicationContext createServletApplicationContext() {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(SpringMVCConfig.class);
        return ctx;
    }
    //设定SpringMVC对应的请求映射路径，设置为/表示拦截所有请求，任意请求都将转入到SpringMVC进行处理
    @Override
    protected String[] getServletMappings() {
        return new String[]{"/"};
    }
    //如果创建Servlet容器时需要加载非SpringMVC对应的bean，使用当前方法进行，使用方式同createServletApplicationContext()
    @Override
    protected WebApplicationContext createRootApplicationContext() {
        return null;
    }
}

3:Controller加载控制与业务Bean加载控制

4：URL传递参数

正常情况下名称对名称

普通参数 save(String name,int age)
封装对象 save(User user)
数组 save(String[] array)
参数设置 array 10、array 20…

名称对不上用@RequestParam

集合 save(@RequestParam List list)
参数设置 list 10、list 20…

5：JSON数据传递参数

5.1：添加JSON数据转换坐标

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

5.2：在body中设置JSON数据并发送

5.3：开启自动转换JSON数据的支持

@Configuration
@ComponentScan("com.my")
@EnableWebMvc    //开启自动转换JSON数据的支持，开启SpringMVC多项辅助功能
public class SpringMVCConfig {
}

5.4：设置接收JSON数据

@Controller
public class UserController {
    @ResponseBody  //将请求中请求体所包含的数据传递给请求参数，此注解一个方法只能使用一次
    @RequestMapping("/listParamForJson")
    public String listParamForJson(@RequestBody List<String> likes){
        System.out.println("list common(json)参数传递==>" + likes);
        return "{'info':'springmvc'}";
    }

6：日期类型参数传递

dataParam(Date date, //2020/2/12
@DateTimeFormat(pattern=“yyyy-MM-dd”) Date date1, //2020-5-17
@DateTimeFormat(pattern=“yyyy/MM/dd HH:mm:ss”) Date date2 //2020/02/20 20:20:20
)

7：响应

//响应页面/跳转页面
@RequestMapping("/toJumpPage")
public String toJumpPage(){
    System.out.println("跳转页面");
    return "page.jsp";
}
//响应纯文本数据
@RequestMapping("/toText")
@ResponseBody
public String toText(){
    System.out.println("返回纯文本数据");
    return "response text";
}
//响应POJO对象
@RequestMapping("/toJsonPOJO")
@ResponseBody
public User toJsonPOJO(){
    System.out.println("返回json对象数据");
    User user = new User();
    user.setName("Tom");
    user.setAge(20);
    return user;
}
//响应POJO集合对象
@RequestMapping("/toJsonList")
@ResponseBody
public List<User> toJsonList(){
    System.out.println("返回JSON集合数据");
    User user1 = new User();
    user1.setName("Tom");
    user1.setAge(15);
    User user2 = new User();
    user2.setName("Jerry");
    user2.setAge(18);
    User user3 = new User();
    user3.setName("Jack");
    user3.setAge(20);
    List<User> users = new ArrayList<>();
    users.add(user1);
    users.add(user2);
    users.add(user3);
    return users;
}

8：REST

8.1：概述

8.2：REST风格案例

// REST/POST
@RequestMapping(value = "/users", method = RequestMethod.POST)
@ResponseBody
public String save() {
    System.out.println("user save...");
    return "{'module':'user save'}";
}
@RequestMapping(value = "/users/{id}",method = RequestMethod.DELETE)
@ResponseBody
public String delete(@PathVariable Integer id) {
    System.out.println("user delete..."+id);
    return "{'module':'user delete'}";
}
@RequestMapping(value = "/users",method = RequestMethod.PUT)
@ResponseBody
public String update(@RequestBody User user){
    System.out.println("user update..."+user);
    return "{'module':'user update'}";
}
//查询
@RequestMapping(value = "/users/{id}",method = RequestMethod.GET)
@ResponseBody
public String getById(@PathVariable Integer id){
    System.out.println("user getById..."+id);
    return "{'module':'user getById'}";
}

8.3：简化

/**
 * 简化REST
 */
@RestController("/book")
public class BookController {
    // REST/POST
    @PostMapping
    public String save() {
        System.out.println("book save...");
        return "{'module':'book save'}";
    }
    @DeleteMapping("/{id}")
    public String delete(@PathVariable Integer id) {
        System.out.println("book delete..."+id);
        return "{'module':'book delete'}";
    }
    @PutMapping
    public String update(@RequestBody Book book){
        System.out.println("book update..."+book);
        return "{'module':'book update'}";
    }
    //查询
    @GetMapping("/{id}")
    public String getById(@PathVariable Integer id){
        System.out.println("book getById..."+id);
        return "{'module':'book getById'}";
    }
    @GetMapping
    public String getAll(){
        System.out.println("book getAll...");
        return "{'module':'book getAll'}";
    }
}

8.4：设置对静态资源的放行

public class SpringMvcSupport extends WebMvcConfigurationSupport {
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        //当访问/pages/???时候，走pages目录下的内容，防止被SpringMVC拦截
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
}

9：表现层返回结果规范化处理

9.1：在controller定义Result类

public class Result {
    private Object data;   //返回数据
    private Integer code;  //返回结果代码
    private String msg;   //消息

9.2：定义返回代码

com.my.controller.Code.java

public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
}

9.3：修改表现层返回类型

@GetMapping
public Result getAll() {
    List<Book> bookList = bookService.getAll();
    Integer code = (bookList == null ? Code.GET_ERR:Code.GET_OK);
    String msg = (bookList == null? "数据查询失败！":"");
    return new Result(code,bookList,msg);
}

10：异常处理

10.1：集中处理

com.my.controller.ProjectExceptionAdvice.java

@RestControllerAdvice   //将类声明为异常处理类
public class ProjectExceptionAdvice {
    @ExceptionHandler(Exception.class)  //定义处理哪一种异常
    public Result doException(Exception ex){
        return new Result(11111,null,"捕捉到异常！");
    }
}

10.2：异常分类

业务异常(BusinessException)

规范的用户行为产生的异常
不规范的用户行为操作产生的异常

系统异常(SystemException)

项目运行过程中可预计且无法避免的异常

其他异常(Exception)

编程人员未预期到的异常

10.3：异常分类处理

10.3.1：定义Result返回体

com.my.controller.Result.java

public class Result {
    private Object data;   //返回数据
    private Integer code;  //返回结果代码
    private String msg;   //消息

10.3.2：定义异常编码

package com.my.controller;
public class Code {
    public static final Integer SAVE_OK = 20011;
    public static final Integer DELETE_OK = 20021;
    public static final Integer UPDATE_OK = 20031;
    public static final Integer GET_OK = 20041;
    public static final Integer SAVE_ERR = 20010;
    public static final Integer DELETE_ERR = 20020;
    public static final Integer UPDATE_ERR = 20030;
    public static final Integer GET_ERR = 20040;
    public static final Integer SYSTEM_ERR = 50001;
    public static final Integer SYSTEM_TIMEOUT_ERR = 50002;
    public static final Integer SYSTEM_UNKNOWN_ERR = 59999;
    public static final Integer BUSINESS_ERR = 60002;
}

10.3.3：定义异常类

package com.my.exception;
public class BusinessException extends RuntimeException{
    private Integer code;
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }
    public BusinessException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }
}

package com.my.exception;
public class SystemException extends RuntimeException{
    private Integer code;
    public Integer getCode() {
        return code;
    }
    public void setCode(Integer code) {
        this.code = code;
    }
    public SystemException(Integer code, String message) {
        super(message);
        this.code = code;
    }
    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }
}

10.3.4：定义异常处理类

package com.my.controller;
import com.my.exception.BusinessException;
import com.my.exception.SystemException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
/**
 * 处理异常
 */
@RestControllerAdvice   //将类声明为异常处理类
public class ProjectExceptionAdvice {
    @ExceptionHandler(SystemException.class)  //定义处理哪一种异常
    public Result doSystemException(SystemException ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员，ex对象发送给开发人员
        return new Result(ex.getCode(),null,ex.getMessage());
    }
    @ExceptionHandler(BusinessException.class)  //定义处理哪一种异常
    public Result doBusinessException(BusinessException ex){
        return new Result(ex.getCode(),null,ex.getMessage());
    }
    @ExceptionHandler(Exception.class)  //定义处理哪一种异常
    public Result doException(Exception ex){
        //记录日志
        //发送消息给运维
        //发送邮件给开发人员，ex对象发送给开发人员
        return new Result(Code.SYSTEM_UNKNOWN_ERR,null,"系统繁忙，请稍后再试!");
    }
}

10.3.5：捕捉异常

com.my.controller.BookController.java

@GetMapping(value = ("/getById"))
public Result getById(@RequestParam("id") Integer id) {
    if(id == 0){
        throw new BusinessException(Code.BUSINESS_ERR,"请规范您的操作!");
    }
    //将可能出现的异常进行包装，转换成自定义异常
    try{
        int i = 1/0;
    }catch (Exception e){
        throw new SystemException(Code.SYSTEM_TIMEOUT_ERR,"服务器访问超时，请稍后再试!",e);
    }
    Book book = bookService.getById(id);
    Integer code = (book == null? Code.GET_ERR:Code.GET_OK);
    String msg = (book == null? "数据查询失败！":"");
    return new Result(code,book,msg);
}

11：拦截器

11.1：声明拦截器的bean，并实现HandlerInterceptor接口(注意：扫描加载bean)

package com.my.controller.interceptor;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Component
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...");
    }
}

11.2：定义配置类，继承WebMvcConfigurationSupport，实现addInterceptor方法(注意：扫描加载配置)

package com.my.config;

@Configuration
public class SpringMvcSupport extends WebMvcConfigurationSupport {
    //设置过滤静态访问资源
    @Override
    protected void addResourceHandlers(ResourceHandlerRegistry registry) {
        registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
        registry.addResourceHandler("/css/**").addResourceLocations("/css/");
        registry.addResourceHandler("/js/**").addResourceLocations("/js/");
        registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
    }
    //自动装配拦截器
    @Autowired
    private ProjectInterceptor projectInterceptor;
    //添加拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");  //设置具体拦截路径,可设置多个
    }
}

11.3：添加扫描路径

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

11.4：简化(注意：侵入式较强)

com.my.config.SpringMvcConfig.java

@Configuration
@ComponentScan({"com.my.controller"})
@EnableWebMvc
public class SpringMvcConfig implements WebMvcConfigurer {
    //自动装配拦截器
    @Autowired
    private ProjectInterceptor projectInterceptor;
    //添加拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(projectInterceptor).addPathPatterns("/books","/books/*");  //设置具体拦截路径
    }
}

11.5：执行流程

11.6：拦截器参数

11.7：拦截器链

四：Maven高级

1：分模块开发

1.1：创建Maven模块

1.2：书写模块代码

1.3：通过Maven指令安装模块到本地仓库(install指令)

2：可选依赖于排除依赖

2.1：可选依赖

true

指对外隐藏当前所依赖的资源----不透明

2.2：排除依赖

指主动断开依赖的资源，被排除的资源无需指定版本-------不需要

3：多环境配置与应用

3.1：多环境

3.2：跳过测试

4：yml文件读取

五：SpringBoot&MybatisPlus

1：快速入门

1.1：导入坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
    </parent>
    <groupId>com.my</groupId>
    <artifactId>MybatisPlus-demo1</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>MybatisPlus-demo1</name>
    <description>MybatisPlus-demo1</description>
    <properties>
        <java.version>11</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.0</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

1.2：创建配置文件(注意空格)

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: root
    password: 440983

1.3：创建Book及BookDao

@Data    //添加Lombok注解
public class Book {
    private int id;
    private String type;
    private String name;
    private String description;
}
@Mapper
public interface BookDao extends BaseMapper<Book> {
}

说明：@Data注解为当前实体类在编译期设置对应的get/set方法，toString方法、hashCode方法、equals方法等
要注意数据库中表的名称要为book

1.4：测试

@SpringBootTest
class ApplicationTests {
    @Autowired
    private BookDao bookDao;
    @Test
    void getByIdTest() {
        Book book = bookDao.selectById(1);
        System.out.println(book);
    }
    @Test
    void updateTest(){
        Book book = new Book();
        book.setId(1);
        book.setDescription("操作系统从入门到入坟");
        int i = bookDao.updateById(book);
        System.out.println(i);
    }
    <!--
        bookDao.deleteBatchIds(List);   <!--多数据按id删除-->
        bookDao.selectBatchIds(List);   <!--多数据按id查询-->
    -->
}

2：分页查询

2.1：设置分页拦截器作为Spring管理的bean

@Configuration
public class MpConfig {
    @Bean
    public MybatisPlusInterceptor pageInterceptor(){
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor());
        return interceptor;
    }
}

2.2：执行分页查询

public void pageTest(){
    IPage<Book> page = new Page<Book>(1, 3);
    bookDao.selectPage(page,null);
    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());
}

3：条件查询

//条件查询
@Test
public void getAllTest(){
    //方式一：按条件查询
    QueryWrapper<Book> qw = new QueryWrapper<Book>();
    qw.lt("id",6);    //小于
    for (Book book : bookDao.selectList(qw)) {
        System.out.println(book);
    }
    //方式二：lambda格式
    QueryWrapper<Book> qw = new QueryWrapper<Book>();
    qw.lambda().lt(Book::getId,6);
    for (Book book : bookDao.selectList(qw)) {
        System.out.println(book);
    }
    //方式三(推荐)
    LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
    lqw.lt(Book::getId,6);
    for (Book book : bookDao.selectList(lqw)) {
        System.out.println(book);
    }
    //多条件查询
    LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
    //4到10之间
    // lqw.lt(Book::getId,10).gt(Book::getId,4);
    //小于4或者大于10
    lqw.lt(Book::getId,4).or().gt(Book::getId,10);
    for (Book book : bookDao.selectList(lqw)) {
        System.out.println(book);
    }
    /*----------------------------------------NULL判定---------------------------------*/
    LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
    BookQuery bookQuery = new BookQuery();
    bookQuery.setId(10);
    bookQuery.setId2(5);
    //lt 小于，le 小于等于
    //gt 大于，ge 大于等于
    //链式编程
    /* 
    lqw.lt(null != bookQuery.getId(),Book::getId,bookQuery.getId())
    .gt(null != bookQuery.getId2(),Book::getId,bookQuery.getId2());
    */
    lqw.lt(null != bookQuery.getId(),Book::getId,bookQuery.getId());
    lqw.gt(null != bookQuery.getId2(),Book::getId,bookQuery.getId2());
    for (Book book : bookDao.selectList(lqw)) {
        System.out.println(book);
    }
    /*----------------------------查询投影---------------------------------*/
    //查询结果包含模型中部分属性
    LambdaQueryWrapper<Book> lqw = new LambdaQueryWrapper<Book>();
    //查询id、书名、描述
    lqw.select(Book::getId,Book::getName,Book::getDescription);
    List<Book> bookList = bookDao.selectList(lqw);
    bookList.forEach(System.out::println);
    //查询结果包含模型中未定义的属性
    QueryWrapper<Book> qw = new QueryWrapper<>();
    /* qw.select("id","name","description");
    for (Book book : bookDao.selectList(qw)) {
        System.out.println(book);
    } */
    qw.select("count(*) as nums,type");
    qw.groupBy("type");
    List<Map<String, Object>> maps = bookDao.selectMaps(qw);
    System.out.println(maps);
    /*-------------------------其他查询---------------------------------*/
    lqw.between(Book::getId,10,20);    //查询id在10到20之间，包含10和20
    lqw.like("计算机");      //like %计算机%
    lqw.likeLeft("计算机");    //like %计算机
    lqw.likeRigt("计算机");    //like 计算机%
}

4：映射匹配兼容性

@Data    //添加Lombok注解
@TableName("tbl_book")   //设置当前类与数据库表之间的对应关系
public class Book {
    private Integer id;
    @TableField(value = "type",select = false)   //value设置数据库表段名称，select：设置是否参与查询
    private String Type;
    private String name;
    private String description;
    @TableField(exist = false)   //设置属性在数据库表段中是否存在，默认为true，此属性无法与value合并使用
    private Integer isON;
}

全局配置

mybatis-plus:
  global-config:
    db-config:
      id-type: auto    <!--设置id生成策略-->
      table-prefix: tbl_   <!--设置表之间对应关系，在所有pojo类名前加上"tbl_"-->

5：逻辑查询

5.1：数据库添加字段用于表示是否删除(注意尽量不要用关键字作为字段名)

5.2：用yml文件全局配置

mybatis-plus:
  global-config:
    banner: false
    db-config:
      logic-delete-field: is_delete   #设置表示逻辑删除的字段
      logic-delete-value: 1        #设置表示删除的值
      logic-not-delete-value: 0    #设置表示未删除的值

5.3：pojo类添加相应属性

// @TableLogic(value = "0",delval = "1")
private Integer is_delete;     //表示逻辑删除

5.4：执行删除操作

@Test
void deleteTest(){
    bookDao.deleteById(3);
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ku5rodfz-1653122017080)(SSM笔记.assets/image-20220521115510938.png)]

注意这时执行的是UPDATE操作
Book::getId,Book::getName,Book::getDescription);
List bookList = bookDao.selectList(lqw);
bookList.forEach(System.out::println);
//查询结果包含模型中未定义的属性
QueryWrapper qw = new QueryWrapper<>();
/* qw.select(“id”,“name”,“description”);
for (Book book : bookDao.selectList(qw)) {
System.out.println(book);
} /
qw.select("count() as nums,type");
qw.groupBy(“type”);
List<Map<String, Object>> maps = bookDao.selectMaps(qw);
System.out.println(maps);
/-------------------------其他查询---------------------------------/
lqw.between(Book::getId,10,20); //查询id在10到20之间，包含10和20
lqw.like(“计算机”); //like %计算机%
lqw.likeLeft(“计算机”); //like %计算机
lqw.likeRigt(“计算机”); //like 计算机%
}

###### 4：映射匹配兼容性
```java
@Data    //添加Lombok注解
@TableName("tbl_book")   //设置当前类与数据库表之间的对应关系
public class Book {
    private Integer id;
    @TableField(value = "type",select = false)   //value设置数据库表段名称，select：设置是否参与查询
    private String Type;
    private String name;
    private String description;
    @TableField(exist = false)   //设置属性在数据库表段中是否存在，默认为true，此属性无法与value合并使用
    private Integer isON;
}

全局配置

mybatis-plus:
  global-config:
    db-config:
      id-type: auto    <!--设置id生成策略-->
      table-prefix: tbl_   <!--设置表之间对应关系，在所有pojo类名前加上"tbl_"-->

5：逻辑查询

5.1：数据库添加字段用于表示是否删除(注意尽量不要用关键字作为字段名)

5.2：用yml文件全局配置

mybatis-plus:
  global-config:
    banner: false
    db-config:
      logic-delete-field: is_delete   #设置表示逻辑删除的字段
      logic-delete-value: 1        #设置表示删除的值
      logic-not-delete-value: 0    #设置表示未删除的值

5.3：pojo类添加相应属性

// @TableLogic(value = "0",delval = "1")
private Integer is_delete;     //表示逻辑删除

5.4：执行删除操作

@Test
void deleteTest(){
    bookDao.deleteById(3);
}

注意这时执行的是UPDATE操作