1. Spring简介

1.1 Spring是什么

Spring是分层的Java SE/EE应用full-stack轻量级开源框架，以IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented
Programming：面向切面编程）为内核。

提供了展现SpringMVC和持久层Spring JDBCTemplate以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java
EE 企业应用开源框架。

1.2 Spring发展历程

1997年，IBM提出了 EJB 的思想

1998年，SUN制定开发标准规范 EJB 1.0

1999年，EJB 1.1 发布

2001年，EJB 2.0 发布

2003年，EJB 2.1 发布

2006年，EJB 3.0 发布

Rob Johnson（Spring之父）

Expert One-to-One J2EE Design and Development(2022)

阐述了 J2EE 使用EJB 开发设计的优缺点及解决方案

Expert One-to-One J2EE Development without EJB(2004)

阐述了 J2EE 开发不使用EJB 的解决方式（Spring雏形）

2017 年9月份发布了Spring的最新版本 Spring5.0 通用版（GA）

1.3 Spring的优势

1）方便解耦，简化开发

​ 通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

2）AOP编程的支持

​ 通过 Spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现。

3）声明式事务的支持

​ 可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务管理，提高开发效率和质量。

4）方便程序的测试

​ 可以用费容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。

5）方便集成各种优秀框架

​ Spring对各种优秀框架（Struct、Hibernate、Hessian、Quartz）的支持。

6）降低JavaEE API 的使用难度

​ Spring对JavaEE API (如JDBC、JavaMail、远程调用等) 进行了薄薄的封装层，使这些API的使用难度大为降低。

7）Java源码是经典学习范例

​ Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java 设计模式灵活运用以及对Java技术的高深造诣。它的源代码无疑是Java技术的最佳实践的范例。

1.4 Spring的体系结构

image-20240215154337044

2. Spring快速入门

2.1 Spring程序开发步骤

IMG_0306

① 导入 Spring开发的基本包坐标

② 编写 Dao接口和实现类

③ 创建 Spring核心配置文件

④ 在 Spring配置文件中配置UserDaoImpl

⑤ 使用 Spring的API获得 Bean实例

Spring的开发步骤：

① 导入坐标

② 创建Bean

③ 创建applicationContext.xml

④ 在配置文件中进行配置

⑤ 创建ApplicationContext对象getBean

3. Spring配置文件

3.1 Bean标签基本配置

用于配置对象交由Spring来创建

默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。

基本属性：

  • id：Bean实例在Spring容器中的唯一标识
  • class：Bean的全限定名称

3.2 Bean标签范围配置

scope：指对象的作用范围，取值如下：

取值范围 说明
singleton 默认值，单例的
prototype 多例的
request WEB 项目中，Spring创建一个Bean 的对象，将对象存入到request域中
session WEB 项目中，Spring创建一个Bean 的对象，将对象存入到session域中
global session WEB 项目中，应用在Portlet环境，如果没有Portlet环境那么globalSession相当于session

测试代码：

1
2
3
4
5
6
7
public void test1(){
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao1 = (UserDao) app.getBean("userDao");
        UserDao userDao2 = (UserDao) app.getBean("userDao");
        System.out.println(userDao1);
        System.out.println(userDao2);
    }

1）当scope的取值为singleton时

​ Bean的实例化个数：1个

​ Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例

​ Bean的生命周期：

  • 对象创建：当应用加载，创建容器时，对象就被创建
  • 对象运行：只要容器在，对象一直活着
  • 对象销毁：当应用卸载，销毁容器时，对象就被销毁了
1
<bean id="userDao" class="com.recallstudy.dao.impl.UserDaoImpl" scope="singleton">
1
2
com.recallstudy.dao.impl.UserDaoImpl@76707e36
com.recallstudy.dao.impl.UserDaoImpl@76707e36

2）当scope的取值为prototype

​ Bean的实例化个数：多个

​ Bean的实例化时机：当调用getBean()方法时实例化Bean

  • 对象创建：当使用对象时，创建新的对象实例
  • 对象运行：只要对象在使用中，就一直活着
  • 对象销毁：当对象长时间不用时，被Java的垃圾回收器回收了
1
<bean id="userDao" class="com.recallstudy.dao.impl.UserDaoImpl" scope="prototype">
1
2
com.recallstudy.dao.impl.UserDaoImpl@76707e36
com.recallstudy.dao.impl.UserDaoImpl@614ddd49

3.3 Bean生命周期配置

  • init-method：指定类中的初始化方法名称
  • destroy-method：指定类中销毁方法名称
1
<bean id="userDao" class="com.recallstudy.dao.impl.UserDaoImpl" init-method="init" destroy-method="destroy"/>

3.4 Bean实例化三种方式

  • 无参构造方法实例化

  • 工厂静态方法实例化

    1
    <bean id="userDao" class="com.recallstudy.factory.StaticFactory" factory-method="getUserDao"/>

  • 工厂实例方法实例化

    1
    2
    <bean id="factory" class="com.recallstudy.factory.DynamicFactory"/>
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"/>

3.5 Bean的依赖注入分析

1
2
<bean id="userDao" class="com.recallstudy.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.recallstudy.service.impl.UserServiceImpl"/>

目前UserService实例和UserDao实例都存在于Spring容器中，当前的做法是在容器外部获得UserService实例和UserDao实例，然后在程序中进行结合。

image-20240215211213442

因为UserService和UserDao都在Spring容器，而最终程序直接使用的是UserService，所以可以在Spring容器中，将UserDao设置到UserService内部。

image-20240215211921957

3.6 Bean的依赖注入概念

依赖注入（Dependency Injection）：它是Spring框架核心IOC的具体现实。

在编写程序时，通过控制反转，把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。

IOC解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。

那这种业务层和持久层的依赖关系，在使用Spring之后，就让Spring来维护了。

简单的说，就是坐等框架把持久化层对象传入业务层，而不用我们自己去获取。

3.7 Bean的依赖注入方式

  • 构造方法
  • set方法

1）set方法注入

1
2
3
<bean id="userService" class="com.recallstudy.service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"></property>
</bean>

​ P命名空间注入本质也是set方法注入，主要体现在配置文件中，如下：

​ 首先，需要引入P命名空间：

1
xmlns:p="http://www.springframework.org/schema/p"

​ 其次，需要修改注入方式

1
<bean id="userService" class="com.recallstudy.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

2）构造方法

1
2
3
<bean id="userService" class="com.recallstudy.service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

3.8 Bean的依赖注入的数据类型

除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

注入数据的三种数据类型

  • 普通数据类型
  • 引用数据类型
  • 集合数据类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<bean id="userDao" class="com.recallstudy.dao.impl.UserDaoImpl">
    <property name="strList">
        <list>
            <value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </property>
    <property name="userMap">
        <map>
            <entry key="u1" value-ref="user1"></entry>
            <entry key="u2" value-ref="user2"></entry>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="p1">ppp1</prop>
            <prop key="p2">ppp2</prop>
            <prop key="p3">ppp3</prop>
        </props>
    </property>
</bean>

<bean id="user1" class="com.recallstudy.domain.User">
<property name="name" value="tom"/>
<property name="addr" value="beijing"/>
</bean>
<bean id="user2" class="com.recallstudy.domain.User">
<property name="name" value="lucy"/>
<property name="addr" value="tianjin"/>
</bean>

3.9 引入其他配置文件（分模块开发）

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

1
<import resource="applicationContext-xxx.xml"/>

3.10 知识要点

Spring的重点配置

标签

​ id属性：在容器中Bean实例的唯一标识，不允许重复

​ class属性：要实例化的Bean的全限定名

​ scope属性：Bean的作用范围，常用是Singleton（默认）和prototype

​ 标签：属性注入

​ name属性：属性名称

​ value属性：注入的普通属性值

​ ref属性：注入的对象引用值

​ < list >标签

​ < map >标签

​ < properties >标签

​ 标签

< import >标签：导入其他的Spring的分文件

4. Spring相关API

4.1 ApplicationContext的继承体系

applicationContext：接口类型，代表应用上下文，可以通过其实例获取得到Spring容器中的Bean 对象

image-20240216162617377

4.2 ApplicationContext的实现类

1）ClassPathXmlApplicationContext

​ 它是从类的根路径下加载配置文件推荐使用这种

2）FileSystemXmlApplicationContext

​ 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。

3）AnnotationConfigApplicationContext

​ 当使用注解配置容器对象时，需要使用此类来创建spring容器。它用来读取注解。

4.3 getBean()方法使用

1
2
3
4
5
6
7
8
9
public Object getBean(String name) throws BeansException {
        this.assertBeanFactoryActive();
        return this.getBeanFactory().getBean(name);
    }
    
public <T> T getBean(Class<T> requiredType) throws BeansException {
        this.assertBeanFactoryActive();
        return this.getBeanFactory().getBean(requiredType);
    }
1
2
3
ApplicationContext app = new     								ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) app.getBean("userService");
UserService userService = app.getBean(UserService.class);

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，这此方法会报错。

4.4 知识要点

Spring的重点API

1
2
3
ApplicationContext app = new ClasspathXmlApplicationContext("xml文件");
app.getBean("id");
app.getBean(Class);

5. Spring配置数据源

5.1 数据源（连接池）的作用

  • 数据源（连接池）是提高程序性能而出现的
  • 事先实例化数据源，初始化部分连接资源
  • 使用连接资源时从数据源中获取
  • 使用完毕后将连接资源归还给数据源

常见的数据源(连接池): DBCP、C3P0、BoneCP、Druid等

5.2 数据源的开发步骤

① 导入数据源的坐标和数据源驱动坐标

② 创建数据源对象

③ 设置数据源的基本连接数据

5.3 数据源的手动创建

1）手动创建 c3p0 数据源

1
2
3
4
5
6
7
8
9
10
11
12
@Test
    //测试手动创建 c3p0 数据源
    public void test1() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUser("root");
        dataSource.setPassword("QY1989424334");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

2）手动创建 druid 数据源

1
2
3
4
5
6
7
8
9
10
11
12
@Test
    //测试手动创建 druid 数据源
    public void test2() throws Exception{
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/test");
        dataSource.setUsername("root");
        dataSource.setPassword("QY1989424334");
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        dataSource.close();
    }

3）手动创建 c3p0 数据源(加载properties配置文件)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Test
    //测试手动创建 c3p0 数据源(加载properties配置文件)
    public void test3() throws Exception {
        //读取配置文件
        ResourceBundle rb = ResourceBundle.getBundle("jdbc");
        String driver = rb.getString("jdbc.driver");
        String url = rb.getString("jdbc.url");
        String username = rb.getString("jdbc.username");
        String password = rb.getString("jdbc.password");
        //创建数据源对象 设置连接参数
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        dataSource.setDriverClass(driver);
        dataSource.setJdbcUrl(url);
        dataSource.setUser(username);
        dataSource.setPassword(password);
        
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
      
    }

5.4 Spring配置数据源

可以将DataSource的创建权交由Spring容器去完成

1
2
3
4
5
6
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test"></property>
    <property name="user" value="root"></property>
    <property name="password" value="QY1989424334"></property>
</bean>
1
2
3
4
5
6
7
8
9
10
@Test
    //测试Spring容器产生数据源对象
    public void test4() throws Exception {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        //DataSources dataSource =(DataSources) app.getBean("dataSource");
        DataSource dataSource = app.getBean(DataSource.class);
        Connection connection=dataSource.getConnection();
        System.out.println(connection);
        connection.close();
    }

5.5 抽取jdbc配置文件

applicationContext.xml加载jdbc.properties配置文件获得连接信息。

首先，需要引入context命名空间和约束路径：

  • 命名空间：

    1
    xmlns:context="http://wwww.springframework.org/schema/context"

  • 约束路径：

    1
    2
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    1
    2
    3
    4
    5
    6
    7
    8
    9
    <!--加载外部的properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${jdbc.driver}"></property>
        <property name="jdbcUrl" value="${jdbc.url}"></property>
        <property name="user" value="${jdbc.username}"></property>
        <property name="password" value="${jdbc.password}"></property>
    </bean>

知识要点

Spring容器加载properties文件

1
2
<context:property-placeholder location="xx.properties"/>
<property name="" value="${key}"/>

6.Spring注解开发

6.1 Spring原始注解

Spring是轻代码而重配置的框架，配置比较繁重，影响开发效率，所以注解开发是一种趋势，注解代替xml配置文件可以简化配置，提高开发效率。

Spring原始注解主要是替代的配置

注解 说明
@Component 使用在类上用于实例化Bean
@Controller 使用在web层类上用于实例化Bean
@Service 使用在service层类上用于实例化Bean
@Repository 使用在dao类层上用于实例化Bean
@Autowired 使用在字段上用于根据类型注入依赖
@Qualifier 结合@Autowired一起使用用于根据名称进行依赖注入
@Resource 相当于@Autowired+@Qualifier，按照名称进行注入
@Value 注入普通属性
@Scope 标注Bean的作用范围
@PostConstruct 使用在方法上标注该方法是Bean的初始化方法
@PreDestroy 使用在方法上标注方法是Bean的销毁方法

注意：

使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

1
2
<!--配置组件扫描-->
<context:component-scan base-package="com.recallstudy"></context:component-scan>

6.2 Spring新注解

使用上面的注解还不能全部代替xml配置文件，还需要使用注解替代的配置如下：

  • 非自定义的Bean的配置：
  • 加载properties文件的配置：
  • 组件扫描的配置：
  • 引入其他文件：
注解 说明
@Configuration 用于指定当前类是一个Spring配置类，当创建容器时会从该类上加载注解
@ComponentScan 用于指定Spring在初始化容器时要扫描的包。作用和在Spring的xml配置文件中的一样
@Bean 使用在方法上，标注将该方法的返回值存储到Spring容器中
@PropertySource 用于加载.properties文件中的配置
@Import 用于导入其他配置类

  1. DataSourceConfiguration.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    //标志该类是Spring的核心配置类
    @Configuration
    //<context:component-scan base-package="com.recallstudy"></context:component-scan>
    @ComponentScan("com.recallstudy")
    //<import resource=""/>
    @Import({DataSourceConfiguration.class})
    public class SpringConfiguration {
        
    }

  2. DataSourceConfiguration.java

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    //<context:property-placeholder location="classpath:jdbc.properties"/>
    @PropertySource("classpath:jdbc.properties")
    public class DataSourceConfiguration {

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

        @Bean("dataSource")  //Spring会将当前方法的返回值以指定名称注册到Spring容器中
        public DataSource getDataSource() throws PropertyVetoException {
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            dataSource.setDriverClass(driver);
            dataSource.setJdbcUrl(url);
            dataSource.setUser(username);
            dataSource.setPassword(password);
            return dataSource;
        }
    }

  3. UserController.java

    1
    ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);

7.Spring集成Junit

7.1 原始Junit测试Spring的问题

在测试类中，每个测试方法都有以下两行代码：

1
2
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。

7.2 上述问题解决思路

  • 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它
  • 将需要进行测试Bean直接在测试类中进行注入

7.3 Spring集成Junit步骤

① 导入spring集成Junit的坐标

② 使用@Runwith注解替换原来的运行期

③ 使用@ContextConfiguration指定配置文件或配置类

④ 使用@Autowired注入需要测试的对象

⑤ 创建测试方法进行测试

1
2
3
4
5
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RunWith(SpringJUnit4ClassRunner.class)
//@ContextConfiguration("classpath:applicationContext.xml")
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {

    @Autowired
    private UserService userService;

    @Autowired
    private DataSource dataSource;

    @Test
    public void test1() throws SQLException {
        userService.save();
        System.out.println(dataSource.getConnection());
    }
}

8.Spring集成web环境

8.1 ApplicationContext应用上下文获取方式

应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件)方式获取的，但是每次从容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件)，这样的弊端是配置文件加载多次，应用上下文对象创建对次。

在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

ContextLoaderListener.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 ContextLoaderListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        ServletContext servletContext = servletContextEvent.getServletContext();
        //读取web.xml中的全局参数
        String contextConfigLocation = servletContext.getInitParameter("contextConfigLocation");
        ApplicationContext app = new ClassPathXmlApplicationContext(contextConfigLocation);
        //将Spring的应用上下文对象存储到ServletContext域中
        servletContext.setAttribute("app", app);
        System.out.println("spring容器创建完毕...");
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {

    }
}

web.xml

1
2
3
4
5
6
7
8
9
10
<!--全局初始化参数-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>applicationContext.xml</param-value>
</context-param>

        <!--配置监听器-->
<listener>
<listener-class>com.recallstudy.listener.ContextLoaderListener</listener-class>
</listener>

UserServlet.java

1
2
3
4
5
6
7
8
9
10
11
12
public class UserServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ServletContext servletContext = this.getServletContext();
        //ApplicationContext app = (ApplicationContext) servletContext.getAttribute("app");
        ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
        UserService userService = app.getBean(UserService.class);
        userService.save();
    }
}

WebApplicationContextUtils.java

1
2
3
4
5
public class WebApplicationContextUtils {
public static ApplicationContext getWebApplicationContext(ServletContext servletContext) {
    return (ApplicationContext) servletContext.getAttribute("app");
}
}

8.2 Spring提供获取应用上下文的工具

Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils

供使用者获得应用上下文对象。

所以我们需要做的只有两件事：

① 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）

1
2
3
4
5
6
7
8
9
10
<!--全局初始化参数-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

        <!--配置监听器-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

② 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

1
2
ServletContext servletContext = this.getServletContext();
ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);

8.3 导入Spring集成web的坐标

1
2
3
4
5
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>

8.4 配置ContextLoaderListener监听器

1
2
3
4
5
6
7
8
9
10
<!--全局初始化参数-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>

        <!--配置监听器-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

8.5通过工具获得应用上下文对象

1
2
ApplicationContext app = WebApplicationContextUtils.getWebApplicationContext(servletContext);
Object obj = applicationContext.getBean("id");

8.6 知识要点

Spring集成web环境步骤

① 配置ContextLoaderListener监听器

② 使用WebApplicationContextUtils获得应用上下文

9.SpringMVC简介

9.1 SpringMVC概述

SpringMVC是一种基本Java的实现MVC设计模型的请求驱动类型的轻量级Web框架，属于SpringFrameWork的后续产品，已经融合在Spring
Web Flow中。

SpringMVC已经成为目前最主流的MVC框架之一，并且随着Spring3.0的发布，全面超越Structs2，成为最优秀的MVC框架。它通过一套注解，让一个简单的Java类成为处理请求的控制器，而无须实现任何接口。同时它还支持RESTful编程风格的请求。

9.2 SpringMVC快速入门

要求：客户端发起请求，服务器端接收请求，执行逻辑并进行视图跳转。

开发步骤：

① 导入SpringMVC相关坐标

② 配置SpringMVC核心控制器DispatcherServlet

③ 创建Controller类和视图页面

④ 使用注解配置Controller类中业务方法的映射地址

⑤ 配置SpringMVC核心文件spring-mvc.xml

⑥ 客户端发起请求测试

9.3 SpringMVC流程图示

image-20240217211853259

9.4 知识要点

SpringMVC的开发步骤

① 导入SpringMVC相关坐标

② 配置SpringMVC核心控制器DispatcherServlet

③ 创建Controller类是视图页面

④ 使用注解配置Controller业务方法的映射地址

⑤ 配置SpringMVC核心文件spring-mvc.xml

⑥ 客户端发起请求测试

10.SpringMVC组件解析

10.1 SpringMVC的执行流程

image-20240217213024311

① 用户发送请求至前端控制器DispatcherServlet

② DispatcherServlet收到请求调用HandlerMapping处理器映射器

③ 处理器映射器找到具体的处理器（可以根据xml配置、注解进行查找），生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet

④ DispatcherServlet调用HandlerAdapter处理器适配器

⑤ HandlerAdapter经过适配器调用具体的处理器（Controller，也叫后端控制器）

⑥ Controller执行完成返回ModelAndView

⑦ HandlerAdapter将controller执行结果ModelAndView返回给DispatcherServlet

⑧ DispatcherServlet将ModelAndView传给ViewResolver视图解析器

⑨ ViewResolver解析后返回具体View

⑩ DispatcherServlet根据View进行渲染视图（即将模型数据填充至视图中）。DispatcherServlet响应用户

10.2 SpringMVC注解解析

@RequestMapping

作用：用于建立请求URL和处理请求方法之间的对应关系

位置：

  • 类上，请求URL的第一级访问目录。此处不写的话，就相当于应用的根目录
  • 方法上，请求URL的第二级访问目录，与类的使用@RequestMapping标注的一级目录一起组成访问虚拟路径

属性：

  • value：拥有指定请求的URL。它和path属性的作用是一样的
  • method：用于指定请求的方式
  • params：用于指定限制请求参数的条件。它支持简单的表达式。要求请求参数的key和value必须和配置的一模一样

例如：

  • params = {"accountName"}，表示请求参数必须有accountName
  • params = {"moneny!100"}，表示请求参数中money不能是100

10.3 SpringMVC注解解析

  1. mvc命名空间引入

    命名空间：

    1
    2
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"

    约束地址：

    1
    2
    3
    4
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd

  2. 组件扫描

    SpringMVC基于Spring容器，所以在进行SpringMVC操作时，需要将Controller存储到Spring容器中，如果使用@Controller注解标注的话，就需要使用<
    context:component-scan base-package=”com.recallstudy.controller”/>进行组件扫描。

    1
    2
    3
    4
    <!--Controller组件扫描-->
    <context:component-scan base-package="com.recallstudy">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

10.4 SpringMVC的XML配置解析

1
2
3
4
5
6
<!--配置内部资源视图解析器-->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- /jsp/success.jsp -->
    <property name="prefix" value="/jsp/"></property>
    <property name="suffix" value=".jsp"></property>
</bean>

10.5 知识要点

SpringMVC的相关组件

  • 前端控制器：DispatcherServlet
  • 处理器映射器：HandlerMapping
  • 处理器适配器：HandlerAdapter
  • 处理器：Handler
  • 视图解析器：ViewResolver
  • 视图：View

SpringMVC的注解和配置

  • 请求映射注解：@RequestMapping

  • 视图解析器配置：

    1
    2
    3
    4
    REDIRECT_URL_PREFIX = "redirect:"
    FORWARD_URL_PREFIX = "forward:"
    prefix = "";
    suffix = "";

11.SpringMVC的数据响应

11.1 SpringMVC的数据响应方式

1）页面跳转

  • 直接返回字符串
  • 通过ModelAndView对象返回

2）回写数据

  • 直接返回字符串
  • 返回对象或集合

11.2 页面跳转

  1. 返回字符串形式

    直接返回字符串：此种方式会将返回的字符串与视图解析器的前后缀拼接后跳转。

    1
    2
    3
    4
    @RequestMapping("/quick")
    public String quickMethod(){
      return "index";
    }
    1
    2
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>

    转发资源地址：/WEB-INF/views/index.jsp

    返回带有前缀的字符串：

    转发：forward:/WEB-INF/views/index.jsp

    重定向：redirect:/index.jsp

  2. 返回ModelAndView对象

    1
    2
    3
    4
    5
    6
    @RequestMapping(value = "/quick3")
    public ModelAndView save3(ModelAndView modelAndView){
        modelAndView.addObject("username","itheima");
        modelAndView.setViewName("success");
        return modelAndView;
    }

11.3 回写数据

  1. 直接返回字符串

    Web集基础阶段，客户端访问服务器端，如果想直接回写字符串作为响应体返回的话，只需要使用response.getWriter().print(“hello
    world”)即可。

    在Controller中回写字符串：

    ① 通过SpringMVC框架注入的response对象，使用response.getWriter().print(“hello world”)回写数据，此时不需要视图跳转，业务方法返回值为void。

    1
    2
    3
    4
    @RequestMapping(value = "/quick6")
        public void save6(HttpServletResponse response) throws IOException {
            response.getWriter().println("hello recall");
        }

    ② 将需要回写的字符串直接返回，但此时需要通过@ResponseBody注解告知SpringMVC框架，方法返回的字符串不是跳转是直接在http响应体中返回。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>2.9.0</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>2.9.0</version>
    </dependency>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    @RequestMapping(value = "/quick9")
        @ResponseBody
        public String save9() throws IOException {
            User user = new User();
            user.setUsername("lisi");
            user.setAge(30);
            //使用json的转换工具将对象转换成json格式字符串再返回
            ObjectMapper objectMapper = new ObjectMapper();
            String json = objectMapper.writeValueAsString(user);
            
            return json;
        }

        @RequestMapping(value = "/quick8")
        @ResponseBody
        public String save8() throws IOException {
            return "{\"username\":\"zhangsan\",\"age\":18}";
        }

        @RequestMapping(value = "/quick7")
        @ResponseBody //告知SpringMVC框架 不进行视图跳转 直接进行数据响应
        public String save7() throws IOException {
            return "hello recall";
        }

  2. 返回对象或集合

    通过SpringMVC帮助我们对对象或集合进行json字符串的转换并回写，为处理器适配器配置消息转换参数，指定使用jackson进行对象或集合的转换，因此需要在spring-mvc.xml中进行如下配置：

    1
    2
    3
    4
    5
    6
    7
    8
    <!--配置处理器映射器-->
    <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
        <property name="messageConverters">
            <list>
                <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
            </list>
        </property>
    </bean>

    在方法上添加@ResponseBody就可以返回json格式的字符串，但是这样配置比较麻烦，配置的代码比较多，因此，我们可以使用mvc的注解驱动代替上述配置。

    1
    2
    <!--mvc的注解驱动-->
    <mvc:annotation-driven/>

    在SpringMVC的各个组件中，处理器映射器、处理器适配器、视图解析器称为SpringMVC的三大组件。使用< mvc:
    annotation-driven/ >
    自动加载RequestMappingHandlerMapping（处理映射器）和RequestMappingHandlerAdapter（处理适配器），可用在Spring-xml.xml配置文件中使用<
    mvc:annotation-driven/ >替代注解处理器和适配器的配置。同时使用< mvc:annotation-driven/ >
    默认底层就会集成jackson进行对象或集合的json格式字符串的转换。

11.4 知识要点

SpringMVC的数据响应方式

1）页面跳转

  • 直接返回字符串
  • 通过ModelAndView对象返回

2）回写数据

  • 直接返回字符串
  • 返回对象或集合

12.SpringMVC获得请求数据

12.1 获得请求参数

客户端请求参数的格式是：name=value&name=value... ...

服务端要获得请求的参数，有时还需要进行数据的封装，SpringMVC可以接收如下类型的参数：

  • 基本类型参数
  • POJO类型参数
  • 数组类型参数
  • 集合类型参数

12.2 获得基本类型参数

Controller中的业务方法的参数名称要与请求参数的name一致，参数值会自动映射匹配。

http://localhost:8080/recall_springmvc/quick9?username=zhangsan&age=12

1
2
3
4
5
6
@RequestMapping("/quick9")
@ResponseBody
public void quickMethod9(String username,int age) throws IOException{
  System.out.println(username);
  System.out.println(age);
}

12.3 获得POJO类型参数

Controller中的业务方法的POJO参数的属性名与请求参数的name一致，参数值会自动映射匹配。

http://localhost:8080/recall_springmvc/quick9?username=zhangsan&age=12

1
2
3
4
5
@RequestMapping(value = "/quick12")
    @ResponseBody
    public void save12(User user) throws IOException {
        System.out.println(user);
    }

12.4 获得数组类型参数

Controller中的业务方法数组名称与请求参数的name一致，参数值会自动映射匹配。

http://localhost:8080/recall_springmvc/quick11?strs=111&strs=222&strs=333

1
2
3
4
5
@RequestMapping(value = "/quick13")
    @ResponseBody
    public void save13(String[] strs) throws IOException {
        System.out.println(Arrays.asList(strs));
    }

12.5 获得集合类型参数

获的集合参数时，要将集合参数包装到一个POJO中才可以。

1
2
3
4
5
@RequestMapping(value = "/quick14")
    @ResponseBody
    public void save14(VO vo) throws IOException {
        System.out.println(vo);
    }

当使用ajax提交时，可以指定contentType为json形式，那么在方法参数位置使用@RequestBody可以直接接收集合数据而无需使用·POJO进行包装。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<script>
    //模拟数据
    var userList = new Array();
    userList.push({username:"zhangsan",age:18});
    userList.push({username:"lisi",age:28});

    $.ajax({
    type:"POST",
    url:"${pageContext.request.contextPath}/user/quick15",
    data:JSON.stringify(userList),
    contentType:"application/json;charset=utf-8"
})

</script>
1
2
3
4
5
@RequestMapping(value = "/quick15")
@ResponseBody
public void save15(@RequestBody List<User> userList) throws IOException {
    System.out.println(userList);
}

静态资源访问的开启：

1
2
3
<!--开放资源的访问-->
<mvc:resources mapping="/js/**" location="/js/"/>
<mvc:resources mapping="/img/**" location="/img/"/>
1
<mvc:default-servlet-handler/>

12.6 请求数据乱码问题

当post请求时，数据会出现乱码，我们可以设置一个过滤器来进行编码的过滤。

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--配置全局过滤的filter-->
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>UTF-8</param-value>
    </init-param>
</filter>
<filter-mapping>
<filter-name>CharacterEncodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

12.7 参数绑定注解@requestParam

当请求的参数名称与Controller的业务方法参数名称不一致时，就需要通过@RequestParam注解显示的绑定。

1
2
3
4
5
@RequestMapping(value = "/quick16")
@ResponseBody
public void save16(@RequestParam("name") String username) throws IOException {
    System.out.println(username);
}

注解@RequestParam还有如下参数可以使用：

  • value：与请求参数名称
  • required：此在指定的请求参数是否必须包含，默认是true，提交时如果没有此参数则报错
  • defaultValue：当没有指定请求参数是，则使用指定的默认值赋值
1
2
3
4
5
@RequestMapping(value = "/quick16")
@ResponseBody
public void save16(@RequestParam(value = "name",required = false,defaultValue = "recall") String username) throws IOException {
    System.out.println(username);
}

12.8 获得Restful风格的参数

Restful是一种软件架构风格、设计风格，而不是标准，只是提供了一组设计原则和约束条件。主要用于客户端和服务器交互类的软件，基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存机制等。

Restful风格的请求是使用”url+请求方式“表示一次请求目的的，HTTP协议里面四个表示操作方式的动词如下：

  • GET：用于获取资源
  • POST：用于新建资源
  • PUT：用于更新资源
  • DELETE：用于删除资源

例如：

  • /user/1 GET：得到 id = 1 的 user
  • /user/1 DELETE：删除 id = 1 的 user
  • /user/1 PUT：更新 id = 1 的 user
  • /user POST：新增 user

上述url地址/user/1中的1就是要过得的请求参数，在SpringMVC中可以使用占位符进行参数绑定。地址/user/1可以写成/user/{id}，占位符{id}对应的就是1的值。在业务方法中我们可以使用@PathVariable注解进行占位符的匹配获取工作。

1
2
3
4
5
@RequestMapping(value = "/quick17/{username}")
@ResponseBody
public void save17(@PathVariable("username") String username) throws IOException {
    System.out.println(username);
}

12.9 自定义类型转换器

  • SpringMVC默认已经提供了一些常用的类型转换器，例如客户端提交的字符串转换成int型进行参数设置。
  • 但是不是所有的数据类型都提供了转换器，没有提供的就需要自定义转换器，例如：日期类型的数据就需要自定义转换器。

自定义类型转换器的开发步骤：

① 定义转换器类实现Converter接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class DateConverter implements Converter<String, Date> {
    @Override
    public Date convert(String dateStr) {
        //将日期的字符串转换成日期对象 返回
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
        Date date = null;
        try {
            date = format.parse(dateStr);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
        return date;
    }
}

② 在配置文件中声明转换器

1
2
3
4
5
6
7
8
<!--声明转化器-->
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <property name="converters">
        <list>
            <bean class="com.recallstudy.converter.DateConverter"></bean>
        </list>
    </property>
</bean>

③ 在< annotation-driven >中引用转换器

1
2
<!--mvc的注解驱动-->
<mvc:annotation-driven conversion-service="conversionService"/>

12.10 获得Servlet相关API

SpringMVC支持使用原始ServletAPI对象作为控制器方法的参数进行注入，常用的对象如下：

  • HttpServletRequest
  • HttpServletResponse
  • HttpSession
1
2
3
4
5
6
7
@RequestMapping(value = "/quick19")
@ResponseBody
public void save19(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws IOException {
    System.out.println(request);
    System.out.println(response);
    System.out.println(session);
}

12.11 获得请求头

  1. @RequestHeader

    使用@RequestHeader可以获得请求头信息，相当于web阶段学习的request.getHeader(name)

    @RequestHeader注解的属性如下：

    • value：请求头的名称
    • required：是否必须携带此请求头
    1
    2
    3
    4
    5
    @RequestMapping(value = "/quick20")
    @ResponseBody
    public void save20(@RequestHeader(value = "User-Agent",required = false) String user_agent) throws IOException {
        System.out.println(user_agent);
    }

  2. @CookieValue

    使用@CookieValue可以获得指定Cookie的值

    @CookieValue注解的属性如下：

    • Value：指定cookie的名称
    • required：是否必须携带此cookie
    1
    2
    3
    4
    5
    @RequestMapping(value = "/quick21")
    @ResponseBody
    public void save21(@CookieValue(value = "JSESSIONID") String jsessionId){
        System.out.println(jsessionId);
    }

12.12 文件上传

  1. 文件上传客户端三要素

    • 表单项type= “file”
    • 表单的提交方式是post
    • 表单的enctype属性是多部分表单形式，及enctype= “multipart/form-data”

  2. 文件上传原理

    • 当form表单修改为多部分表单时，request.getParameter()将失效。
    • enctype= “application/x-www-form-urlencoded” 时，form表单的正文内容格式是：key=value&key=value&key=value
    • 当form表单的enctype取值为Multipart/form-dat时，请求正文内容就变成多部分形式：

    image-20240220170118368

12.13 单文件上传步骤

① 导入fileupload和io坐标

② 配置文件上传解析器

③ 编写文件上传代码

12.14 单文件上传实现

① 导入fileupload和io坐标

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
</dependency>
<dependency>
<groupId>commons-io</groupId>
<artifactId>commons-io</artifactId>
<version>2.3</version>
</dependency>

② 配置文件上传解析器

1
2
3
4
5
<!--配置文件上传解析器-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="defaultEncoding" value="UTF-8"/>
    <property name="maxUploadSize" value="500000"/>
</bean>

③ 编写上传文件代码

1
2
3
4
5
6
7
8
@RequestMapping(value = "/quick22")
@ResponseBody
public void save22(String username, MultipartFile uploadFile) throws IOException {
    System.out.println(username);
    //获得上传文件的名称
    String originalFilename = uploadFile.getOriginalFilename();
    uploadFile.transferTo(new File("/Users/zhouyu/Programming_ learning/Java/SSM/Spring/recallstudy_spring_mvc/src/main/webapp/upload/"+originalFilename));
}

12.15 多文件上传实现

多文件上传，只需要将页面修改为多个文件上传项，将方法参数MultipartFile类型修改为MultipartFile[]即可

1
2
3
4
5
6
7
8
9
@RequestMapping(value = "/quick23")
@ResponseBody
public void save23(String username, MultipartFile[] uploadFile) throws IOException {
    System.out.println(username);
    for (MultipartFile multipartFile : uploadFile) {
        String originalFilename = multipartFile.getOriginalFilename();
        multipartFile.transferTo(new File("/Users/zhouyu/Programming_ learning/Java/SSM/Spring/recallstudy_spring_mvc/src/main/webapp/upload/" + originalFilename));
    }
}

12.16 知识要点

MVC实现数据请求方式

  • 基本类型参数
  • POJO类型参数
  • 数组类型参数
  • 集合类型参数

MVC获取数据细节

  • 中文乱码问题
  • @RequestParam 和 @PathVariable
  • 自定义类型装换器
  • 获得Servlet相关API
  • @RequestHeader 和 @CookieValue
  • 文件上传

13.Spring JdbcTemplate基本使用

13.1 JdbcTemplate概述

它是spring框架中提供的一个对象，是对原始繁琐的Jdbc
API对象的简单封装。spring框架为我们提供了很多操作模版类。例如：操作关系型数据的JdbcTemplate和HibernateTemplate，操作nosql数据库的RedisTemplate，操作消息队列的JmsTemplate等等。

13.2 JdbcTemplate开发步骤

① 导入spring-jdbc和spring-tx坐标

② 创建数据库和实体

③ 创建jdbcTemplate对象

④ 执行数据库操作

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.0.5.RELEASE</version>
</dependency>

13.3 Spring产生JdbcTemplate对象

我们可以将JdbcTemplate的创建权给Spring，将数据源DataSource的创建权也交给Spring，在Spring容器内部将数据源DataSource注入到JdbcTemplate模版对象中，配置如下

1
2
3
4
5
6
7
8
9
10
11
12
13
<!--加载jdbc.properties-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--数据源对象-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driver}"></property>
<property name="jdbcUrl" value="${jdbc.url}"></property>
<property name="user" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!--jdbc模版对象-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean>

13.4 JdbcTemplate的常用操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcTemplateCRUD {

@Autowired
private JdbcTemplate jdbcTemplate;

@Test
public void testUpdate() {
    int row = jdbcTemplate.update("update account set money = ? where name = ? ", 10000, "lisi");
}

@Test
public void testDelete() {
    int row = jdbcTemplate.update("delete from account where name = ? ", "lisi");
}

@Test
public void testQueryAll() {
    List<Account> accountList = jdbcTemplate.query("select * from account", new BeanPropertyRowMapper<Account>(Account.class));
    System.out.println(accountList);
}

@Test
public void testQueryOne() {
    Account account = jdbcTemplate.queryForObject("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), "tom");
    System.out.println(account);
}

@Test
public void testQueryCount() {
    Long count = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
    System.out.println(count);
}
}

13.5 知识要点

① 导入 spring-jdbc和spring-tx坐标

② 创建数据库表和实体

③ 创建JdbcTemplate对象

1
2
JdbcTemplate jdbcTemplate = new JdbcTemplate();
jdbcTemplate.setDataSource(dataSource);

④ 执行数据库操作

​ 更新操作：

1
jdbcTemplate.update(sql,params)

​ 查询操作：

1
2
jdbcTemplate.query(sql,Mapper,params)
jdbcTemplate.queryForObject(sql,Mapper,params)

14.SpringMVC拦截器

14.1 拦截器（interceptor）的作用

Spring MVC的拦截器类似于Servlet 开发中的过滤器Filter，用于对处理器进行预处理和后处理。

将拦截器按一定的顺序结成一条链，这条链称为拦截器链（Interceptor Chain）。在访问被拦截的方法或字段时，拦截器链中的拦截器就会按其之前定义的顺序被调用。拦截器也是AOP思想的具体实现。

14.2 拦截器和过滤器区别

区别 过滤器（Filter） 拦截器（Interceptor）
使用范围 是Servlet规范中的一部分，任何Java Web工程都可以使用 是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能用
拦截范围 在 url-pattern 中配置了/*之后，可以对所有要访问的资源拦截 在中配置了/** 之后，也可以多所有资源进行拦截，但是可以通过标签排除不需要拦截的资源

14.3 拦截器的快速入门

自定义拦截器的步骤：

① 创建拦截器类实现HandlerInterceptor接口

1
2
3
4
5
6
//在目标方法执行之前 执行
preHandle
//在目标方法执行之后 视图对象返回之前执行
postHandle
//在流程都执行完毕后 执行
afterCompletion

② 配置拦截器

1
2
3
4
5
6
7
8
<!--配置拦截器-->
<mvc:interceptors>
    <mvc:interceptor>
        <!--对哪些资源执行拦截操作-->
        <mvc:mapping path="/**"/>
        <bean class="com.recallstudy.interceptor.MyInterceptor1"/>
    </mvc:interceptor>
</mvc:interceptors>

③ 测试拦截器的拦截效果

1
2
3
4
5
6
7
8
//执行顺序
MyInterceptor1 preHandle......
MyInterceptor2 preHandle......
目标资源执行......
MyInterceptor2 postHandle......
MyInterceptor1 postHandle......
MyInterceptor2 afterCompletion......
MyInterceptor1 afterCompletion......

14.4 拦截器方法说明

方法名 说明
preHandle() 方法将在请求处理之前进行调用，该方法的返回值是布尔值Boolean类型的，当它返回为false时，表示请求结束，后续的Interceptor和Controller都不会再执行；当放回值为true时就会继续调用下一个Interceptor的preHandle方法
postHandle() 该方法是在当前请求进行处理之后被调用，前提是preHandle方法的返回值为true 时才能被调用，且它会在DispatcherServlet进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller处理之后的ModelAndView对象进行操作
afterCompletion() 该方法将在整个请求结束之后，也就是在DispatcherServlet渲染了对应的视图之后执行，前提是preHandle方法的返回值为true时才能被调用

14.5 知识要点

自定义拦截器步骤

① 创建拦截器类实现HandlerInterceptor接口

② 配置拦截器

③ 测试拦截器的拦截效果

15.SpringMVC异常处理

15.1 异常处理的思路

系统中异常包括两类：预期异常和运行时异常RuntimeException，前者通过捕获异常从而获取异常信息，后者主要通过规范代码开发、测试等手段减少运行时异常的发生。

系统的Dao、Service、Controller出现都通过throws Exception向上抛出，最后由SpringMVC前端控制器交由异常处理器进行异常处理，如下图：

image-20240222215949860

15.2 异常处理两种方式

  • 使用Spring MVC提供的简单异常处理器SimpleMappingExceptionResolver
  • 实现Spring的异常处理接口HandlerExceptionResolve自定义自己的异常处理器

15.3 简单异常处理器SimpleMappingExceptionResolver

SpringMVC已经定义好了该类型装换器，在使用时可以根据项目情况进行相应异常与视图的映射配置

image-20240222222325229

15.4 自定义异常处理步骤

① 创建异常处理器类实现HandlerExceptionResolver

② 配置异常处理器

③ 编写异常页面

④ 测试异常跳转

15.5 知识要点

异常处理方式

  • 配置简单异常处理器SimpleMappingExceptionResolver
  • 自定义异常处理器

自定义异常处理步骤

① 创建异常处理器类实现HandlerExceptionResolver

② 配置异常处理器

③ 编写异常页面

④ 测试异常跳转

16.Spring的AOP简介

16.1 什么是AOP

AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

16.2 AOP的作用及其优势

  • 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
  • 优势：减少重复代码，提高开发效率，并且便于维护

16.3 AOP的底层实现

实际上，AOP的底层是通过Spring提供的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

16.4 AOP的动态代理技术

常用的动态代理技术

  • JDK代理：基于接口的动态代理技术
  • cglib代理：基于父类的动态代理技术

image-20240223165331991

JDK动态代理和CGlib动态代理的区别：

  1. JDK动态代理是面向接口的，只能增强实现类中存在的方法。CGlib是面向父类的，可以增强父类的所有方法
  2. JDK得到的对象是JDK代理对象实例，而CGlib得到的对象是被代理对象的子类

16.5 JDK的动态代理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class ProxyTest {
    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //获得增强对象
        Advance advance = new Advance();
        //返回值 就是动态生成的代理对象
        TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
                target.getClass().getClassLoader(), //目标对象类加载器
                target.getClass().getInterfaces(), //目标对象相同的接口字节码对象数组
                new InvocationHandler() {
                    //调用代理对象的任何方法 实质执行的都是invoke方法
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //前置增强
                        advance.before();
                        Object invoke = method.invoke(target, args);//执行目标方法
                        //后置增强
                        advance.after();
                        return invoke;
                    }
                }
        );
        //调用代理对象的方法
        proxy.save();
    }
}

16.6 cglib的动态代理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class ProxyTest {
    public static void main(String[] args) {
        //目标对象
        final Target target = new Target();
        //获得增强对象
        Advance advance = new Advance();
        //返回值 就是动态生成的代理对象  基于cglib
        //1、创建增强器
        Enhancer enhancer = new Enhancer();
        //2、设置父类（目标）
        enhancer.setSuperclass(Target.class);
        //3、设置回调
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                advance.before();//执行前置
                Object invoke = method.invoke(target, args);//执行目标
                advance.after();//执行后置
                return invoke;
            }
        });
        //4、创建代理对象
        Target proxy = (Target) enhancer.create();
        proxy.save();
    }
}

16.7 AOP 相关概念

Spring的AOP实现底层就是对上面的动态代理的代码进行了封装，封装后我们只需要对需要关注的部分进行代码编写，并通过配置的方式完成指定目标的方法增强。

AOP的常用相关术语：

  • Target（目标对象）：代理的目标对象
  • Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类
  • Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点
  • PointCut（切入点）：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
  • Advice（通知/增强）：所谓通知是指拦截到Joinpoint之后所要做的事情就是通知
  • Aspect（切面）：是切入点和通知（引介）的结合
  • Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

16.8 AOP开发明确的事项

  1. 需要编写的内容

    • 编写核心业务代码（目标类的目标方法）

    • -编写切面类，切面类中有通知（增强功能方法）

    • 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

  2. AOP技术实现的内容

    Spring框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。

  3. AOP底层使用哪种代理方式

    在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

16.9 知识要点

  • aop：面向切面编程

  • aop底层实现：基于JDK的动态代理和基于Cglib的动态代理

  • aop的重点概念：

    Pointcut（切入点）：被增强的方法

    Advice（通知/增强）：封装增强业务逻辑的方法

    Aspect（切面）：切点+通知

    Weaving（织入）：将切点与通知结合的过程

  • 开发明确事项：

    谁是切点（切点表达式配置）

    谁是通知（切面类中的增强方法）

    将切点和通知进行织入配置

17.基于XML的AOP开发

17.1 快速入门

① 导入AOP相关坐标

② 创建目录接口和目标类（内部有切点）

③ 创建切面类（内部有增强方法）

④ 将目标类和切面类的对象创建权交给spring

⑤ 在 applicationContext.xml 中配置织入关系

⑥ 测试代码

1
2
3
4
5
6
7
8
9
10
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.4</version>
</dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!--目标对象-->
<bean id="target" class="com.recallstudy.aop.Target"></bean>

        <!--切面对象-->
<bean id="myAspect" class="com.recallstudy.aop.MyAspect"></bean>

        <!--配置织入：告诉spring框架 哪些方法(切点)需要进行哪些增强(前置、后置...)-->
<aop:config>
<!--声明切面-->
<aop:aspect ref="myAspect">
    <!--切面：切点+通知-->
    <aop:before method="before" pointcut="execution(public void com.recallstudy.aop.Target.save())"></aop:before>
</aop:aspect>
</aop:config>

17.2 XML配置AOP详解

  1. 切点表达式的写法

    表达式语法：

    1
    execution([修饰符] 返回值类型 包名.类名.方法名(参数))
    • 访问修饰符可以省略
    • 返回值类型、包名、类名、方法名可以使用星号* 代表任意
    • 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
    • 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表

    例如

    1
    2
    3
    4
    5
    execution(public void com.recallstudy.aop.Target.method())
    execution(void com.recallstudy.aop.Target.*(..))
    execution(* com.recallstudy.aop.*.*(..))
    execution(* com.recallstudy.aop..*.*(..))
    execution(* *..*.*(..))

  2. 通知的类型

    通知的配置语法：

    1
    <aop:通知类型 method="切面类中方法名" pointcut="切点表达式"></aop:通知类型>

    | 名称 | 标签 | 说明 |
    |————|————————————-|————————————————|
    | 前置通知 | < aop:before > | 用于配置前置通知。指定增强的方法在切入点方法之前执行 |
    | 后置通知 | < aop:after-returning > | 用于配置后置通知。指定增强的方法在切入点方法之后执行 |
    | 环绕通知 | < aop:around > | 用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行 |
    | 异常抛出通知 | < aop:throwing > | 用于配置异常抛出通知。指定增强的方法在出现异常时执行 |
    | 最终通知 | < aop:after > | 用于配置最终通知。无论增强方式执行是否有异常都会执行 |

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    <!--配置织入：告诉spring框架 哪些方法(切点)需要进行哪些增强(前置、后置...)-->
    <aop:config>
        <!--声明切面-->
        <aop:aspect ref="myAspect">
            <!--切面：切点+通知-->
            <!--<aop:before method="before" pointcut="execution(public void com.recallstudy.aop.Target.save())"></aop:before>-->
            <!--<aop:before method="before" pointcut="execution(* com.recallstudy.aop.*.*(..))"/>-->
            <!--<aop:after-returning method="afterReturning" pointcut="execution(* com.recallstudy.aop.*.*(..))"/>-->
            <aop:around method="around" pointcut="execution(* com.recallstudy.aop.*.*(..))"/>
            <aop:after-throwing method="afterThrowing" pointcut="execution(* com.recallstudy.aop.*.*(..))"/>
            <aop:after method="after" pointcut="execution(* com.recallstudy.aop.*.*(..))"/>
        </aop:aspect>
    </aop:config>

  3. 切点表达式的抽取

    当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用pointcut-ref属性代替pointcut属性来引用抽取后的切点表达式。

    1
    2
    3
    4
    5
    6
    7
    8
    <aop:config>
      <!--引用MyAspect的Bean位切面对象-->
      <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* com.recallstudy.aop.*.*(..))"></aop:pointcut>
        <aop:around method="around" pointcut-ref="myPointcut"/>
        <aop:after method="after" pointcut-ref="myPointcut"/>
      </aop:aspect>
    </aop:config>

17.3 知识要点

  • aop织入的配置

    1
    2
    3
    4
    5
    <aop:config>
      <aop:aspect ref="切面类">
        <aop:before method="通知方法名称" pointcut="切点表达式"></aop:before>
      </aop:aspect>
    </aop:config>

  • 通知的类型：前置通知、后置通知、环绕通知、异常抛出通知、最终通知

  • 切点表达式的写法：

    1
    execution([修饰符])返回值类型 包名.类名.方法名(参数))

18.基于注解的AOP开发

18.1 快速入门

基于注解的aop开发步骤：

① 创建目标接口和目标类（内部有切点）

② 创建切面类（内部有增强方法）

③ 将目标类和切面类的对象创建权交给spring

④ 在切面类中使用注解配置织入关系

⑤ 在配置文件中开启组件扫描和AOP的自动代理

1
2
3
4
<!--组件扫描-->
<context:component-scan base-package="com.recallstudy.anno"/>
        <!--aop自动代理-->
<aop:aspectj-autoproxy/>

⑥ 测试

18.2 注解配置AOP详解

  1. 注解通知的类型

    通知的配置语法：@通知注解(“切点表达式”)

名称 注解 说明
前置通知 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知 @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知 @Around 用于配置环绕通知。指定增强的方法切入点方法之前和之后都执行
异常抛出通知 @AfterThrowing 用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知 @After 用于配置最终通知。无论增强方式执行是否有异常都会执行

  1. 切点表达式的抽取

    同xml配置aop一样，我们可以将切点表达式抽取。抽取方式是在切面内定义方法，在该方法上使用@Pointcut注解定义切点表达式，然后在增强注解中进行引用。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    //定义切点表达式
    @Pointcut("execution(* com.recallstudy.anno.*.*(..))")
    public void pointcut(){}

    @Around("pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前增强......");
        Object proceed = pjp.proceed();//切点方法
        System.out.println("环绕后增强......");
        return proceed;
    }

    @After("MyAspect.pointcut()")
    public void after(){
        System.out.println("最终增强......");
    }

18.3 知识要点

  • 注解aop开发步骤

    ① 使用@Aspect标注切面类

    ② 使用@通知注解标注通知方法

    ③ 在配置文件中配置aop自动代理< aop:aspectj-autoproxy />

  • 通知注解类型

名称 注解 说明
前置通知 @Before 用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知 @AfterReturning 用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知 @Around 用于配置环绕通知。指定增强的方法切入点方法之前和之后都执行
异常抛出通知 @AfterThrowing 用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知 @After 用于配置最终通知。无论增强方式执行是否有异常都会执行

19.编程式事务控制相关对象

19.1 PlatformTransactionManager

PlatformTransactionManager接口是spring的事务管理器，它里面提供了我们常用的操作事务的方法。

方法 说明
TransactionStatus
getTransaction(TransactionDefinition definition)		 获取事务的状态信息
void commit (TransactionStatus status) 提交事务
void rollback(TransactionStatus status) 回滚事务

注意：

PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如：

Dao层技术是jdbc或mybatis时：org.springframework.jdbc.datasource.DataSourceTransactionManager

Dao层技术是hibernate时：org.springframework.orm.hibernate5.HibernateTransactionManager

19.2 TransactionDefinition

TransactionDefinition是事务的定义信息对象，里面有如下方法：

方法 说明
int getIsolationLevel() 获得事务的隔离级别
int getPropagationBehavior() 获得事务的传播行为
int getTimeout() 获得超时时间
boolean isReadOnly() 是否只读

  1. 事务隔离级别

    设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读。

    • ISOLATION_DEFAULT
    • ISOLATION_READ_UNCOMMITTED
    • ISOLATION_READ_COMMITTED
    • ISOLATION_REPEATABLE_READ
    • ISOLATION_SERIALIZABLE

  2. 事务传播行为

    • REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
    • SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
    • MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
    • REQUITERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。
    • NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
    • NEVER：以非事务方式运行，如果当前存在事务，抛出异常
    • NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作
    • 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
    • 是否只读：建议查询时设置为只读

19.3 TransactionStatus

TransactionStatus接口提供的是事务具体的运行状态，方法介绍如下。

方法 说明
boolean hasSavepoint() 是否存储回滚点
boolean isCompleted() 事务是否完成
boolean isNewTransaction() 是否是新事务
boolean isRollbackOnly() 事务是否回滚

19.4 知识要点

编程式事务控制三大对象

  • PlatformTransactionManager
  • TransactionDefinition
  • TransactionStatus

20.基于XML的声明式事务控制

20.1 什么是声明式事务控制

Spring的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在Spring配置文件中声明式的处理事务来代理代码式的处理事务。

声明式事务处理的作用

  • 事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可
  • 在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来极其方便

注意：Spring声明式事务控制底层就是AOP。

20.2 声明式事务控制的实现

声明式事务控制明确事项：

  • 谁是切点？
  • 谁是通知？
  • 配置切面？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--配置平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

        <!--通知 事务的增强-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--设置事务的属性信息-->
<tx:attributes>
    <tx:method name="*"/>
</tx:attributes>
</tx:advice>

        <!--配置事务的aop织入-->
<aop:config>
<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.recallstudy.service.impl.*.*(..))"></aop:advisor>
</aop:config>

20.3 切点方法的事务参数的配置

1
2
3
4
5
6
<!--通知 事务的增强-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>

其中，< tx:methode >代表切点方法的事务参数的配置，例如：

1
<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/>
  • name：切点方法名称
  • isolation：事务的隔离级别
  • propogation：事务的传播行为
  • timeout：超时时间
  • read-only：是否只读
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<!--配置平台事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

        <!--通知 事务的增强-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!--设置事务的属性信息-->
<tx:attributes>
    <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
    <tx:method name="save" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>
    <tx:method name="findAll" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>
    <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>
    <tx:method name="*"/>
</tx:attributes>
</tx:advice>

        <!--配置事务的aop织入-->
<aop:config>
<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.recallstudy.service.impl.*.*(..))"/>
</aop:config>

20.4 知识要点

声明式事务控制的配置要点

  • 平台事务管理器配置
  • 事务通知的配置
  • 事务aop织入的配置

21.基于注解的声明式事务控制

1
2
<!--事物的注解驱动-->
<tx:annotation-driven transaction-manager="transactionManager"/>

① 使用@Transaction在需要进行事务控制的类或是方法上修饰，注解可用的属性同xml配置方式，例如隔离级别、传播行为等。

② 注解使用在类上，那么该类下的所有方法都使用同一套注解参数配置。

③ 使用在方法上，不同的方法可以采用不同的事务参数配置。

④ Xml配置文件中要开启事务的注解驱动< tx:annotation-driven />

22.MyBatis简介

22.1 原始jdbc操作（查询数据）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//获得连接
Connection connection = DriverManager.getConnection("jdbc:mysql:///test","root","root");
//获得statement
PreparedStatement statement = connection.prepareStatement("select id,username,password from user");
//执行查询
ResultSet resultSet = statement.executeQuery();
//遍历结果集
while(resultSet.next()){
  //封装实体
  User user = new User();
  user.setId(resultSet.getInt("id"));
  user.setUsername(resultSet.getString("username"));
  user.setPassword(resultSet.getString("password"));
  //user实体封装完毕
  System.out.println(user);
}
//释放资源
resultSet.close();
statement.close();
connection.close();

原始jdbc操作（插入数据）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
//模拟实体对象
User user = new User();
user.setId(2);
user.setUsername("tom");
user.setPassword("lucy");

//注册驱动
Class.forName("com.mysql.cj.jdbc.Driver");
//获得连接
Connection connection = DriverManager.getConnection("jdbc:mysql:///test","root","root");
//获得statement
PreparedStatement statement = connection.prepareStatement("insert into user(id,username,password) values(?,?,?)");
//设置占位符
statement.setInt(1, user.getId());
statement.setString(2, user.getUsername());
statement.setString(3, user.getPassword());
//执行更新操作
statement.executeUpdate();
//释放资源
statement.close();
connection.close();

22.2 原始jdbc操作的分析

原始jdbc开发存在的问题如下：
① 数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能

② sql语句在代码中硬编码，造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。

③ 查询操作时，需要手动将结果集中的数据手动封装到实体中。插入操作时，需要手动将实体的数据设置到sql语句的占位符位置

应对上述问题给出的解决方案：

① 使用数据库连接池初始化连接资源

② 将sql语句抽取到xml配置文件中

③ 使用反射、内省等底层技术，自动将实体与表进行属性与字段的自动映射

22.3 什么是Mybatis

  • mybatis是一个优秀的基于java的持久层框架，它内部封装了jdbc，使开发者只需要关注sql语句本身，而不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。
  • mybatis通过xml或注解的方式将要执行的各种statement配置起来，并通过java对象和statement中sql的动态参数进行映射生成最终执行的sql语句。
  • 最后mybatis框架执行sql并将结果映射为java对象返回。采用ORM思想解决了实体和数据库映射的问题，对jdbc进行了封装，屏蔽了jdbc
    api底层访问细节，使我们不用与jdbc api打交道，就可以完成对数据库的持久化操作。

23.Mybatis的快速入门

23.1 Mybatis开发步骤

MyBatis官网地址：http://www.mybatis.org/mybatis-3/

MyBatis开发步骤：

① 添加MyBatis的坐标

② 创建user数据表

③ 编写User实体类

④ 编写映射文件UserMapper.xml

⑤ 编写核心文件SqlMapConfig.xml

⑥ 编写测试类

23.2 环境搭建

  1. 导入MyBatis的坐标和其他相关坐标

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    <!--mysql驱动坐标-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.33</version>
    </dependency>
            <!--mybatis坐标-->
    <dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.1</version>
    </dependency>
            <!--单元测试坐标-->
    <dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.1</version>
    <scope>test</scope>
    </dependency>
            <!--日志坐标-->
    <dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
    </dependency>

  2. 创建user数据表

    image-20240225154043881

  3. 编写User实体

    1
    2
    3
    4
    5
    6
    public class User {
        private int id;
        private String username;
        private String password;
      	//省略get和set方法
    }

  4. 编写UserMapper映射文件

    1
    2
    3
    4
    5
    6
    7
    8
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="userMapper">
        <select id="findAll" resultType="com.recall.domain.User">
            select *
            from user
        </select>
    </mapper>

  5. 编写MyBatis核心文件

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>

        <!--数据源环境-->
        <environments default="development">
            <environment id="development">
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.cj.jdbc.Driver>"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
                    <property name="username" value="root"/>
                    <property name="password" value="QY1989424334"/>
                </dataSource>
            </environment>
        </environments>
        
        <!--加载映射文件-->
        <mappers>
            <mapper resource="com/recall/mapper/UserMapper.xml"></mapper>
        </mappers>
        
    </configuration>

23.3 编写测试代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
//加载核心配置文件
InputStream resourceAsStream = Resources. getResourceAsStream("SqlMapConfig.xml");

//获得sqlSession工厂对象
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

//获得sqlSession对象
SqlSession sqlSession = sqlSessionFactory.openSession();

//执行sql语句
List<User> userList = sqlSession.selectList ("userMapper.findAll");

//打印结果
System. out.println(userList);

//释放资源
sqlSession.close();

23.4 知识小结

MyBatis开发步骤：

① 添加MyBatis的坐标

② 创建user数据表

③ 编写User实体类

④ 编写映射文件UserMapper.xml

⑤ 编写核心文件SqlMapConfig.xml

⑥ 编写测试类

24.MyBatis的映射文件概述

image-20240225164328602

25.MyBatis的增删改查操作

25.1 MyBatis的插入数据操作

  1. 编写UserMapper映射文件

    1
    2
    3
    4
    <!--插入操作-->
    <insert id="save" parameterType="com.recall.domain.User">
        insert into user values(#{id},#{username},#{password})
    </insert>

  2. 编写插入实体User的代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //获得核心配置文件
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    //获得session工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    //获得session会话对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //执行操作  参数：namespace+id
    sqlSession.insert("userMapper.save", user);
    //mybatis执行更新操作  提交事务
    sqlSession.commit();
    //释放资源
    sqlSession.close();

  3. 插入操作注意问题

    • 插入语句使用insert标签
    • 在映射文件中使用parameterType属性指定要插入的数据类型
    • Sql语句中使用#{实体属性名}方式引用实体中的属性值
    • 插入操作使用的API是sqlSession.insert(“命名空间.id”,实体对象);
    • 插入操作涉及数据库数据变化，所以要使用sqlSession对象显示的提交事务，即sqlSession.commit()

25.2 MyBatis的修改数据操作

  1. 编写UserMapper映射文件

    1
    2
    3
    4
    <!--修改操作-->
    <update id="update" parameterType="com.recall.domain.User">
        update user set username=#{username},password=#{password} where id=#{id}
    </update>

  2. 编写修改实体User的代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //获得核心配置文件
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    //获得session工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    //获得session会话对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //执行操作  参数：namespace+id
    sqlSession.update("userMapper.update", user);
    //mybatis执行更新操作  提交事务
    sqlSession.commit();
    //释放资源
    sqlSession.close();

  3. 修改操作注意问题

    • 修改语句使用update标签
    • 修改操作使用的API是sqlSession.update(“命名空间.id”,实体对象);

25.3 MyBatis的删除数据操作

  1. 编写UserMapper映射文件

    1
    2
    3
    4
    <!--删除操作-->
    <delete id="delete" parameterType="java.lang.Integer">
        delete from user where id=#{id}
    </delete>

  2. 编写删除数据的代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //获得核心配置文件
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    //获得session工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    //获得session会话对象
    SqlSession sqlSession = sqlSessionFactory.openSession();
    //执行操作  参数：namespace+id
    sqlSession.delete("userMapper.delete",7 );
    //mybatis执行更新操作  提交事务
    sqlSession.commit();
    //释放资源
    sqlSession.close();

  3. 删除操作注意问题

    • 删除语句使用delete标签
    • Sql语句中使用#{任意字符串}方式引用传递的单个参数
    • 删除操作使用的API是sqlSession.delete(“命名空间.id”,Object);

25.4 知识小结

增删改查映射配置与API：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<!--删除操作-->
<delete id="delete" parameterType="java.lang.Integer">
    delete from user where id=#{id}
</delete>
        <!--修改操作-->
<update id="update" parameterType="com.recall.domain.User">
update user set username=#{username},password=#{password} where id=#{id}
</update>
        <!--插入操作-->
<insert id="save" parameterType="com.recall.domain.User">
insert into user values(#{id},#{username},#{password})
</insert>
        <!--查询操作-->
<select id="findAll" resultType="com.recall.domain.User">
select *
from user
</select>
1
2
3
4
sqlSession.delete("userMapper.delete",7 );//删除数据
sqlSession.update("userMapper.update", user);//更新数据
sqlSession.insert("userMapper.save", user);//插入数据
List<User> userList = sqlSession.selectList("userMapper.findAll");//查询数据

26.MyBatis核心配置文件概述

26.1 MyBatis核心配置文件层级关系

image-20240225181327547

26.2 MyBatis常用配置解析

  1. environments标签

    数据库环境的配置，支持多环境配置

    image-20240225182150235

    其中，事务管理器（transactionManager）类型有两种：

    • JDBC：这个配置就是直接使用了JDBC的提交和回滚设置，它依赖于从数据源得到的连接来管理事务作用域。
    • MANAGED：这个配置几乎没做什么。它从来不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。
      默认情况下它会关闭连接，然而一些容器并不希望这样，因此需要将 closeConnection 属性设置 为 false 来阻止它默认的关闭行为。

    其中，数据源（dataSource）类型有三种：

    • UNPOOLED：这个数据源的实现只是每次被请求时打开和关闭连接。
    • POOLED ：这种数据源的实现利用“池”的概念将 JDBC 连接对象组织起来。
    • JNDI：这个数据源的实现是为了能在如 EJB 或应用服务器这类容器中使用，容器可以集中或在外部配置数据源，然后放置 一个 JNDI
      上下文的引用。

  2. mapper标签

    该标签的作用是加载映射的，加载方式有如下几种：

    • 使用相对于类路径的资源引用，例如：

    • 使用完全限定资源定位符（URL），例如：

    • 使用映射器接口实现类的完全限定类名，例如：

    • 将包内的映射器接口实现全部注册为映射器，例如：

  3. Properties标签

    实际开发中，习惯将数据源的配置信息单独抽取成一个properties文件，该标签可以加载额外配置的properties文件

    image-20240225184225513

  4. typeAliases标签

    类型别名是为Java 类型设置一个短的名字。原来的类型名称配置如下

    image-20240225184308693

    上面我们是自定义的别名，mybatis框架已经为我们设置好的一些常用的类型的别名

别名 数据类型
string String
long Long
int Integer
double Double
boolean Boolean
… … … …

26.3 知识小结

核心配置文件常用配置：

  1. properties标签：该标签可以加载外部的properties文件

    1
    2
    <!--通过properties标签加载properties文件-->
    <properties resource="jdbc.properties"></properties>

  2. typeAliases标签：设置类型别名

    1
    2
    3
    4
    <!--定义别名-->
    <typeAliases>
        <typeAlias type="com.recall.domain.User" alias="user"></typeAlias>
    </typeAliases>

  3. mappers标签：加载映射配置

    1
    2
    3
    4
    <!--加载映射文件-->
    <mappers>
        <mapper resource="com/recall/mapper/UserMapper.xml"></mapper>
    </mappers>

  4. environments标签：数据源环境配置标签

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    <!--数据源环境-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"></transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>

27.MyBatis相应API

27.1 SqlSession工厂构建器SqlSessionFactoryBuilder

常用API：SqlSessionFactory build(InputStream inputStream) 通过加载mybatis的核心文件的输入流的形式构建一个SqlSessionFactory对象

1
2
3
4
String resource = " org/mybatis/builder/mybatis-config.xml" ;
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder(); 
SqlSessionFactory factory = builder.build(inputStream);

其中， Resources 工具类，这个类在 org.apache.ibatis.io 包中。Resources 类帮助你从类路径下、文件系统或 一个 web URL 中加载资源文件。

27.2 SqlSession工厂对象SqlSessionFactory

SqlSessionFactory 有多个个方法创建 SqlSession 实例。常用的有如下两个：

方法 解释
openSession() 会默认开启一个事务，但事务不会自动提交，也就意味着需要手动提 交该事务，更新操作数据才会持久化到数据库中
openSession(boolean autoCommit) 参数为是否自动提交，如果设置为true，那么不需要手动提交事务

27.3 SqlSession会话对象

SqlSession 实例在 MyBatis 中是非常强大的一个类。在这里你会看到所有执行语句、提交或回滚事务和获取映射器实例的方法。
执行语句的方法主要有：

1
2
3
4
5
<T> T selectOne(String statement, Object parameter)
<E> List<E> selectList(String statement, Object parameter) 
int insert(String statement, Object parameter)
int update(String statement, Object parameter) 
int delete(String statement, Object parameter)

操作业务的方法主要有：

1
2
void commit()
void rollback()

28.MyBatis的Dao层实现

28.1 传统开发方式

  1. 编写UserDao接口

    1
    2
    3
    public interface UserDao {
    List<User> findAll() throws IOException;
    }

  2. 编写UserDaoImpl实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    public class UserMapperImpl implements UserMapper {
    @Override
    public List<User> findAll() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        List<User> userListt = sqlSession.selectList("userMapper.findAll");
        return userListt;
    }
    }

  3. 测试传统方式

    1
    2
    3
    4
    5
    6
    7
    8
    public class ServiceDemo {
    public static void main(String[] args) throws IOException {
        //创建dao层对象  当前dao层实现是手动编写的
        UserMapper userMapper = new UserMapperImpl();
        List<User> all = userMapper.findAll();
        System.out.println(all);
    }
    }

28.2 代理开发方式

  1. 采用 Mybatis 的代理开发方式实现 DAO 层的开发，这种方式是我们后面进入企业的主流。 Mapper 接口开发方法只需要程序员编写Mapper
    接口（相当于Dao 接口），由Mybatis 框架根据接口定义创建接 口的动态代理对象，代理对象的方法体同上边Dao接口实现类方法。

    Mapper 接口开发需要遵循以下规范：

    1. Mapper.xml文件中的namespace与mapper接口的全限定名相同
    2. Mapper接口方法名和Mapper.xml中定义的每个statement的id相同
    3. Mapper接口方法的输入参数类型和mapper.xml中定义的每个sql的parameterType的类型相同
    4. Mapper接口方法的输出参数类型和mapper.xml中定义的每个sql的resultType的类型相同

  2. 编写UserMapper接口

    image-20240225201915699

  3. 测试代理方式

    1
    2
    3
    4
    5
    6
    7
    8
    9
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> all = mapper.findAll();
    System.out.println(all);
    User user = mapper.findById(1);
    System.out.println(user);
    sqlSession.close

28.3 知识小结

MyBatis的Dao层实现的两种方式：

  • 手动对Dao进行实现：传统开发方式

  • 代理方式对Dao进行实现：

    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);

    image-20240225201915699

29.Mybatis映射文件深入

29.1 动态sql语句

  1. 动态sql语句概述

    Mybatis 的映射文件中，前面我们的 SQL 都是比较简单的，有些时候业务逻辑复杂时，我们的 SQL是动态变化的， 此时在前面的学习中我们的
    SQL 就不能满足要求了。 参考的官方文档，描述如下：

    image-20240225204551273

  2. 动态SQL之

    我们根据实体类的不同取值，使用不同的 SQL语句来进行查询。比如在 id如果不为空时可以根据id查询，如果 username
    不同空时还要加入用户名作为条件。这种情况在我们的多条件组合查询中 经常会碰到。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    <select id="findByCondition" parameterType="user" resultType="user">
        select * from user
        <where>
            <if test="id!=0">
                and id=#{id}
            </if>
            <if test="username!=null">
                and username=#{username}
            </if>
            <if test="password!=null">
                and password=#{password}
            </if>
        </where>
    </select>

  3. 动态 SQL 之

    循环执行sql的拼接操作，例如：SELECT * FROM USER WHERE id IN (1,2,5)。

    1
    2
    3
    4
    5
    6
    7
    8
    <select id="findByIds" parameterType="list" resultType="user">
        select * from user
        <where>
            <foreach collection="list" open="id in(" close=")" item="id" separator=",">
                #{id}
            </foreach>
        </where>
    </select>

    foreach标签的属性含义如下：

    标签用于遍历集合，它的属性：

    • collection：代表要遍历的集合元素，注意编写时不要写#{}
    • open：代表语句的开始部分
    • close：代表结束部分
    • item：代表遍历集合的每个元素，生成的变量名
    • sperator：代表分隔符

29.2 SQL片段抽取

Sql 中可将重复的 sql 提取出来，使用时用 include 引用即可，最终达到 sql 重用的目的

image-20240225213405171

29.3 知识小结

MyBatis映射文件配置：

1
2
3
4
5
6
7
8
9

<select>：查询
    <insert>：插入
        <update>：修改
            <delete>：删除
                <where>：where条件
                    <if>：if 判断
                        <foreach>：循环
                            <sql>：sql片段抽取

30.MyBatis核心配置文件深入

30.1 typeHandlers标签

无论是 MyBatis 在预处理语句（PreparedStatement）中设置一个参数时，还是从结果集中取出一个值时， 都会用 类型处理器将获取的值以合适的方式转换成
Java 类型。下表描述了一些默认的类型处理器（截取部分）。

image-20240226133041980

可以重写类型处理器或创建你自己的类型处理器来处理不支持的或非标准的类型。具体做法为：实现
org.apache.ibatis.type.TypeHandler 接口， 或继承一个很便利的类 org.apache.ibatis.type.BaseTypeHandler， 然
后可以选择性地将它映射到一个JDBC类型。例如需求：一个Java中的Date数据类型，我想将之存到数据库的时候存成一
个1970年至今的毫秒数，取出来时转换成java的Date，即java的Date与数据库的varchar毫秒值之间转换。

开发步骤：

① 定义转换类继承类BaseTypeHandler

② 覆盖4个未实现的方法，其中setNonNullParameter为java程序设置数据到数据库的回调方法，getNullableResult 为查询时
mysql的字符串类型转换成 java的Type类型的方法

③ 在MyBatis核心配置文件中进行注册

④ 测试转换是否正确

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class DateTypeHandler extends BaseTypeHandler<Date> {
//将java类型 转换成 数据库需要的类型
@Override
public void setNonNullParameter(PreparedStatement preparedStatement, int i, Date date, JdbcType jdbcType) throws SQLException {
    long time = date.getTime();
    preparedStatement.setLong(i,time);
}

//将数据库中类型 转换成java类型
//String参数 要转换的字段名称
//ResultSet 查询出的结果集
@Override
public Date getNullableResult(ResultSet resultSet, String s) throws SQLException {
    //获取结果集中需要的数据(long) 转换成Date类型 返回
    long aLong = resultSet.getLong(s);
    Date date = new Date(aLong);
    return date;
}

//将数据库中类型 转换成java类型
@Override
public Date getNullableResult(ResultSet resultSet, int i) throws SQLException {
    long aLong = resultSet.getLong(i);
    Date date = new Date(aLong);
    return date;
}

//将数据库中类型 转换成java类型
@Override
public Date getNullableResult(CallableStatement callableStatement, int i) throws SQLException {
    long aLong = callableStatement.getLong(i);
    Date date = new Date(aLong);
    return date;
}
}

1
2
3
4
<!--注册类型处理器-->
<typeHandlers>
    <typeHandler handler="com.recallstudy.handler.DateTypeHandler"></typeHandler>
</typeHandlers>

30.2 plugins标签

MyBatis可以使用第三方的插件来对功能进行扩展，分页助手PageHelper是将分页的复杂操作进行封装，使用简单的方式即 可获得分页的相关数据

开发步骤:

① 导入通用PageHelper的坐标

1
2
3
4
5
6
7
8
9
10
11
<!--分页助手-->
<dependency>
    <groupId>com.github.pagehelper</groupId>
    <artifactId>pagehelper</artifactId>
    <version>3.7.5</version>
</dependency>
<dependency>
<groupId>com.github.jsqlparser</groupId>
<artifactId>jsqlparser</artifactId>
<version>0.9.1</version>
</dependency>

② 在mybatis核心配置文件中配置PageHelper插件

1
2
3
4
5
6
7
<!--配置分页助手插件-->
<plugins>
    <plugin interceptor="com.github.pagehelper.PageHelper">
        <!--指定方言-->
        <property name="dialect" value="mysql"></property>
    </plugin>
</plugins>

③ 测试分页数据获取

1
2
3
4
5
6
7
//设置分页的相关参数 当前页+每页显示的条数
PageHelper.startPage(1, 3);

List<User> userList = mapper.findAll();
for (User user : userList) {
    System.out.println(user);
}

获得分页相关的其他参数

1
2
3
4
5
6
7
8
9
10
//获得与分页相关参数
PageInfo<User> pageInfo = new PageInfo<User>(userList);
System.out.println("当前页：" + pageInfo.getPageNum());
System.out.println("当页显示条数：" + pageInfo.getPageSize());
System.out.println("总条数：" + pageInfo.getTotal());
System.out.println("总页数：" + pageInfo.getPages());
System.out.println("上一页：" + pageInfo.getPrePage());
System.out.println("下一页：" + pageInfo.getNextPage());
System.out.println("是否是第一页：" + pageInfo.isIsFirstPage());
System.out.println("是否是最后一页：" + pageInfo.isIsLastPage());

30.3 知识小结

MyBatis核心配置文件常用标签:

  1. properties标签：该标签可以加载外部的properties文件
  2. typeAliases标签：设置类型别名
  3. environments标签：数据源环境配置标签
  4. typeHandlers标签：配置自定义类型处理器
  5. plugins标签：配置MyBatis的插件

31.MyBatis的多表操作

31.1 一对一查询

  1. 一对一查询的模型

    用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户 一对一查询的需求：查询一个订单，与此同时查询出该订单所属的用户

    image-20240226153427233

  2. 一对一查询的语句

    对应的sql语句：select * from orders o,user u where o.uid=u.id;

    查询的结果如下：

    image-20240226153739540

  3. 创建Order和User实体

    image-20240226153904437

  4. 创建OrderMapper接口

    image-20240226154019368

  5. 配置OrderMapper.xml

    image-20240226154053823

    其中还可以配置如下：

    image-20240226154130887

  6. 测试结果

    image-20240226154201652

31.2 一对多查询

  1. 一对多查询的模型

    用户表和订单表的关系为，一个用户有多个订单，一个订单只从属于一个用户 一对多查询的需求：查询一个用户，与此同时查询出该用户具有的订单

    image-20240226154307831

  2. 一对多查询的语句

    对应的sql语句：select *,o.id oid from user u left join orders o on u.id=o.uid;

    查询的结果如下：

    image-20240226154348179

  3. 修改User实体

    image-20240226154419672

  4. 创建UserMapper接口

    image-20240226154445298

  5. 配置UserMapper.xml

    image-20240226154540488

  6. 测试结果

    image-20240226154616149

    image-20240226154636504

31.3 多对多查询

  1. 多对多查询的模型

    用户表和角色表的关系为，一个用户有多个角色，一个角色被多个用户使用 多对多查询的需求：查询用户同时查询出该用户的所有角色

    image-20240226154803410

  2. 多对多查询的语句

    对应的sql语句：select u.,r.,r.id rid from user u left join user_role ur on u.id=ur.user_id inner join role r on
    ur.role_id=r.id;

    查询的结果如下：

    image-20240226154840575

  3. 创建Role实体，修改User实体

    image-20240226154933317

  4. 添加UserMapper接口方法

    image-20240226154957311

  5. 配置UserMapper.xml

    image-20240226155023933

  6. 测试结果

    image-20240226155048499

    image-20240226155111666

31.4 知识小结

MyBatis多表配置方式：

一对一配置：使用做配置

一对多配置：使用+做配置

多对多配置：使用+做配置

32.Mybatis的注解开发

32.1 MyBatis的常用注解

这几年来注解开发越来越流行，Mybatis也可以使用注解开发方式，这样我们就可以减少编写Mapper映射文件了。

@Insert：实现新增

@Update：实现更新

@Delete：实现删除

@Select：实现查询

@Result：实现结果集封装

@Results：可以与@Result 一起使用，封装多个结果集

@One：实现一对一结果集封装

@Many：实现一对多结果集封装

32.2 MyBatis的增删改查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
public class MyBatisTest {

private UserMapper mapper;

@Before
public void before() throws IOException {
    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
    SqlSession sqlSession = sqlSessionFactory.openSession(true);
    mapper = sqlSession.getMapper(UserMapper.class);
}


@Test
public void testSave(){
    User user = new User();
    user.setUsername("tom");
    user.setPassword("abc");
    mapper.save(user);
}

@Test
public void testUpdate(){
    User user = new User();
    user.setId(1);
    user.setUsername("lucy");
    user.setPassword("123");
    mapper.update(user);
}

@Test
public void testDelete(){
    mapper.delete(8);
}

@Test
public void testFindById(){
    User user = mapper.findById(2);
    System.out.println(user);
}

@Test
public void testFindAll(){
    List<User> userList = mapper.findAll();
    for (User user : userList) {
        System.out.println(user);
    }
}

}

修改MyBatis的核心配置文件，我们使用了注解替代的映射文件，所以我们只需要加载使用了注解的 Mapper接口即可

1
2
3
4
5

<mappers>
    <!--扫描使用注解的类-->
    <mapper class="com.recallstudy.mapper.UserMapper"/>
</mappers>

或者指定扫描包含映射关系的接口所在的包也可以

1
2
3
4
5

<mappers>
    <!--扫描使用注解的类所在的包-->
    <package name="com.recallstudy.mapper"/>
</mappers>

32.3 MyBatis的注解实现复杂映射开发

注解 说明
@Results 代替的是标签<resultMap>该注解中可以使用单个@Result注解，也可以使用@Result 集 合。使用格式：@Results（{@Result（），@Result（）}）或@Results（@Result（））
@Result 代替了标签和标签
@Result中属性介绍：
column：数据库的列名
property：需要装配的属性名
one ：需要使用的@One 注解（@Result （one=@One）（）））
many：需要使用的@Many 注解（@Result （many=@many）（）））
@One （一对一） 代替了 标签，是多表查询的关键，在注解中用来指定子查询返回单一对象。 @One注解属性介绍：
select: 指定用来多表查询的 sqlmapper <br>使用格式：@Result(column=” “,property=””,one=@One(select=””))
@Many （多对一） 代替了 标签, 是是多表查询的关键，在注解中用来指定子查询返回对象集合。 使用格式：@Result(property=””,column=””,many=@Many(select=””))

32.4 一对一查询

image-20240226211524175

32.5 一对多查询

image-20240226211621367

32.6 多对多查询

image-20240226211716603

33.SSM框架整合

33.1 准备工作

  1. 原始方式整合
    1
    2
    3
    4
    create database ssm; create table account(
    id int primary key auto_increment,
    name varchar(100),
    money double(7,2) );
    image-20240226222548388
  2. 创建Maven工程
    image-20240226222631160

  3. 导入Maven坐标

  4. 编写实体类

    1
    2
    3
    4
    5
    6
    public class Account {
        private int id; 
        private String name; 
        private double money; 
        //省略getter和setter方法
    }

  5. 编写Mapper接口

    1
    2
    3
    4
    5
    6
    7
    public interface AccountMapper {
        //保存账户数据
        void save(Account account);

        //查询账户数据
        List<Account> findAll();
    }

  6. 编写Service接口

    1
    2
    3
    4
    public interface AccountService { 
      void save(Account account); //保存账户数据 
      List<Account> findAll(); //查询账户数据 
    }

  7. 编写Service接口实现

    image-20240226223253391

  8. 编写Controller

    image-20240226223322237

  9. 编写添加页面

    image-20240226223346649

  10. 编写列表页面

    image-20240226223401485

  11. 编写相应配置文件

    • Spring配置文件：applicationContext.xml
    • SpringMVC配置文件：spring-mvc.xml
    • MyBatis映射文件：AccountMapper.xml
    • MyBatis核心文件：sqlMapConfig.xml
    • 数据库连接信息文件：jdbc.properties
    • Web.xml文件：web.xml
    • 日志文件：log4j.xml

  12. 测试添加账户

    image-20240226223601694

  13. 测试账户列表

    image-20240226223625795

33.2 Spring整合MyBatis

  1. 整合思路

    image-20240226223711833

  2. 将SqlSessionFactory配置到Spring容器中

    image-20240226223742161

  3. 扫描Mapper，让Spring容器产生Mapper实现类

    image-20240226223806080

  4. 配置声明式事务控制

    image-20240226223833523

  5. .修改Service实现类代码

    image-20240226223851561