华清远见-重庆中心-框架阶段技术总结

框架

一套规范。

实际是他人实现的一系列接口和类的集合。通入导入对应框架的jar文件(maven项目导入对应的依赖)，

进行适当的配置，就能使用其中的所有内容。

开发者可以省去很多模板代码，如dao中的CRUD，MVC模式下层与层之间的关联。只需要集中精力实现

项目中的业务逻辑部分。

Java主流框架

Spring、SpringMVC、MyBatis、MyBatisPlus、Hibernate、JPA等。

SSH:最初是Spring+Stucts2+Hibernate组成，之后Stucts2被SpringMVC取代。

SSM:Spring+SpringMVC+MyBatis

新项目使用SpringBoot，早期的SSH项目由于维护成本高，基本不会推翻重做，但会维护一些SSM项

目。

无论是SSH还是SSM，Spring、SpringMVC必不可少。从2004年推出至今，依旧是主流框架中不可获取

的一部分。

Spring

概念

一个轻量级开源的Java框架。是一个管理项目中对象的容器，同时也是其他框架的粘合器，目的就是对

项目进行解耦。

轻量级：对原有代码的侵入很小。

Spring的核心是IOC控制反转和AOP面向切面编程

控制反转(IOC)是一种思想，就是让创建对象的控制权由自身交给第三方，控制反转这种思想，通

过依赖注入(DI)的方式实现。

IOC和DI其实都是在描述控制反转，IOC是思想，DI是具体实现方式。

这里的第三方，就是Spring。Spring是一个容器，可以管理所有对象的创建和他们之间的依赖关系。

可以理解为："Spring就是用来管理对象的，在需要用到某个对象的时候，帮我们自动创建"。

如Servlet+JSP模式写Web项目时，会在控制层Servlet中创建业务逻辑层Service对象，在Service层中创

建数据访问层Dao对象。

有了Spring后，就不会出现new这些对象的代码了。

Spring需要导入对应的jar文件后，定义一个配置文件，在该配置文件中配置程序运行过程中所需的对

象。

Spring控制台应用

1. 创建一个普通的Maven项目，不选择模板

2. 添加Spring核心依赖

<!-- spring-context表示spring核心容器 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>

3. 创建一个Java类

4.创建Spring配置文件

创建一个Spring的配置文件，在其中注入上一步创建的类的对象

在resources目录下，创建一个xml文件，选择spring config，通常命名为application

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--bean标签表示，在Spring容器中，注入某个类的对象-->
<!--class属性表示要注入哪个类，写类的全限定名(包名+类名)-->
<!--id表示给类的对象的名称-->
<bean class="com.hqyj.spring01.PlainOrdinaryJavaObject" id="pojo"></bean>
</beans>

5.创建main方法所在类

解析Spring配置文件，获取注入的对象。

package com.hqyj.spring01;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
//创建一个自定义类的对象
//传统方式创建对象
//PlainOrdinaryJavaObject pojo = new PlainOrdinaryJavaObject();
//使用spring容器获取对象
//创建一个用于解析Spring配置文件的对象,参数为配置文件的名称。实际就是获取Spring容器
ClassPathXmlApplicationContext context = new
ClassPathXmlApplicationContext("application.xml");
//获取容器中的对象
/*
只通过名称获取，返回值为Object类型，需要转换
Object obj = context.getBean("pojo");
PlainOrdinaryJavaObject pojo=(PlainOrdinaryJavaObject) obj;
*/
//使用这种方式，直接用指定类型接收
PlainOrdinaryJavaObject pojo = context.getBean("pojo",
PlainOrdinaryJavaObject.class);
//能成功调用方法，说明Spring管理了该类的对象
pojo.fun();
//关闭Spring容器
context.close();
}
}

默认情况下，通过 <bean> 标签定义的类，在Spring容器初始化时，创建一个对象。

bean标签常用属性

属性注入

给某个bean添加属性的方式有两种：构造器注入和setter注入

setter注入

这种方式注入属性时，类中必须要有set方法

在bean标签中，加入 <property></property> 标签，

该标签的name属性通常表示该对象的某个属性名，但实际是setXXX()方法中的XXX单词。

如有age属性，但get方法为getNianLing()，name属性就需要写成nianLing。

该标签的value属性表示给该类中的某个属性赋值，该属性的类型为原始类型或String。

该标签的ref属性表示给该类中除String以外的引用类型属性赋值，值为Spring容器中另一个bean的id。

<!--注入Car类对象并用set方式注入其属性-->
<bean class="com.hqyj.spring01.Car" id="c">
<!--该属性是字符串或原始类型，使用value赋值-->
<property name="brand" value="宝马"></property>
<!--name并不是类中是属性名，而是该属性对应的getXXX()方法中XXX的名称-->
<!--如Car类中有color属性，但get方法名为getColo(),这里就要写为colo-->
<property name="colo" value="白色"></property>
</bean>
<!--注入Person类对象并用set方式注入其属性-->
<bean class="com.hqyj.spring01.Person" id="p1">
<property name="name" value="王海"></property>
<property name="age" value="22"></property>
<!--属性是引用类型，需要通过ref赋值，值为另外的bean的id ref即references-->
<property name="car" ref="c"></property>
</bean>

构造方法注入

这种方式注入属性时，类中必须要有相应的构造方法

在bean标签中，加入 <constructor-arg></constructor-arg> 标签，

该标签的name属性表示构造方法的参数名，index属性表示构造方法的参数索引。

赋值时，原始类型和字符串用value，引用类型用ref。

<!--注入Person类对象并用构造方法注入其属性-->
<bean class="com.hqyj.spring01.Person" id="p2">
<!--constructor-arg表示构造方法参数 name是参数名 index是参数索引-->
<constructor-arg name="name" value="张明"></constructor-arg>
<constructor-arg index="1" value="20"></constructor-arg>
<constructor-arg name="car" ref="c"></constructor-arg>
</bean>

属性自动注入autowire

以上所有案例中，如果要在A对象中注入一个引用类型的对象B，都是手动将对象B注入到对象A中。

如在Person中注入Car对象，在Cinema中注入Movie等。

这种情况下，如果当某个被注入的bean的id更改后，所有引用了该bean的地方都要进行修改。

所以将手动注入更改为自动注入(自动装配)，就无需添加相应的 <property> 标签，甚至可以无需定义

bean的id。

autowire属性的值

byType

类中要有被注入的属性的setter()方法

被自动注入的对象可以没有id

Spring容器中，某个对象的类型要与该setter()方法的参数类型一致，且容器中只有一个该类

型的对象。

如setCar(Car c)，Spring就会自动在容器中寻找类型为Car的对象自动装配

byName

类中要有被注入的属性的setter()方法

被自动注入的对象必须要有id

实际是根据setXXX()方法set后的单词XXX关联

如setCar(Car c),Spring就会自动在容器中寻找id为car的对象自动装配

在Web项目中，可以利用自动装配，在控制层中自动装配业务逻辑层的对象，在业务逻辑层中自动装配

数据访问层的对象。

Spring核心注解

在Spring配置文件中加入

<!--设置要扫描的包，扫描这个包下所有使用了注解的类-->
<context:component-scan base-package="com.hqyj.spring02.bookSystem">
</context:component-scan>

类上加的注解

@Component

当一个类不好归纳时，定义为普通组件

@Controller

定义一个类为控制层组件

@Service

定义一个类为业务层组件

@Repository

定义一个类为持久层(数组访问层)组件

@Lazy/@Lazy(value=true)

设置该类为懒加载。

@Scope(value="singleton/prototype")

设置为单例/原型模式。

说明

以上注解公共特点

都是将对应类的对象注入到Spring容器中，用于替换配置文件中的bean标签

都默认是单例模式非懒加载

默认注入的对象id为当前类的类名首字母小写形式

如在BookDao类上添加，id默认为bookDao

可以通过注解的value属性自定义注入的对象的id名，如@Component(value="key")表示注入的对

象id为key

属性上加的注解

@Autowired

优先使用byType方式从Spring容器中获取对应类型的对象自动装配。先检索Spring容器中对

应类型对象的数量，如果数量为0直接报错；数量为1直接装配

数量大于1，会再尝试使用byName方式获取对应id的对象，但要配合@Qualifier(value="某

个对象的id")一起使用，指定id进行装配

@Qualifier(value="某个对象的id")

<!--设置要扫描的包，扫描这个包下所有使用了注解的类-->

<context:component-scan base-package="com.hqyj.spring02.bookSystem">

</context:component-scan>配合@Autowired注解，使用byName方式获取某个对象id的bean进行装配

@Resource(name="某个对象的id")

该注解相当于@Autowired+@Qualifier(value="某个对象的id")

优先使用byName方式，从Spring容器中检索name为指定名的对象进行装配，如果没有则尝

试使用byType方式，要求对象有且只有一个，否则也会报错。

说明

如果要在某个类中使用Spring容器中的某个对象时，只需定义成员变量，无需创建对象，通过

@Autowired或@Resource注解进行自动装配

实际开发中，绝大部分情况下，需要自动装配对象有且只有一个，并且命名规范，所以

@Autowired或@Resource区别不是很大。@Autowired优先使用byType方式，@Resource优先使

用byName方式

如果@Resource不能使用，是因为缺少javax.annotation包，需要引入对应依赖

<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
<version>1.3.2</version>
</dependency>

在Web项目中使用Spring

1.创建基于Maven的web-app项目

2.添加依赖

<!--servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<!--spring容器-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>
<!--web集成spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.23</version>
</dependency>

3.在main目录下创建java和resources目录，修改web.xml版本为4.0

4.在resources目录下创建Spring配置文件application.xml，扫描使用了注解的根包

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--扫描使用了Spring注解的根包-->
<context:component-scan base-package="com.hqyj.springweb">
</context:component-scan>
</beans>

5.创建一个类，使用@Componet注解将其注入到Spring容器中

package com.hqyj.springweb.entity;
import org.springframework.stereotype.Component;
@Component
public class Pojo {
public void fun(){
System.out.println("hello springweb!");
}
}

如何初始化Spring容器(解析Spring配置文件)

在控制台应用程序中，可以在main方法中通过ClassPathXmlApplicationContext来解析Spring配置文

件，初始化Spring容器。

在web项目中没有main方法，只有servlet中的service方法，如果在service方法中创建

ClassPathXmlApplicationContext对象，会每次访问都执行。

而Spring容器只需初始化一次，在项目启动时就解析Spring配置文件，全局监听器就是一个很好的选

择。

spring-web包中提供了一个ContextLoaderListener类，它实现了ServletContextListener，属于项目

级别的全局监听器。

这个类需要一个contextConfigLocation参数，表示要解析的Spring配置文件的路径。

这个监听器会在项目启动时，读取指定的Spring配置文件路径，并且创建WebApplicationContext对

象，即Spring容器。

6.在web.xml中配置监听器用于初始化Spring容器

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--配置监听器ContextLoaderListener-->
<listener>
<!--监听器全限定名-->
<listenerclass>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--定义全局参数contextConfigLocation用于读取Spring配置文件-->
<context-param>
<!--参数名固定contextConfigLocation-->
<param-name>contextConfigLocation</param-name>
<!--只是Spring配置文件的路径 classpath:表示从根目录出发-->
<param-value>classpath:application.xml</param-value>
</context-param>
</web-app>

7.创建一个Servlet，访问该Servlet，获取Spring容器，从容器中获取注入的对象

package com.hqyj.springweb.controller;
import com.hqyj.springweb.entity.Pojo;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
@WebServlet("/hello")
public class MyServlet extends HttpServlet {
@Override
protected void service(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
//获取Spring容器
WebApplicationContext app =
WebApplicationContextUtils.getWebApplicationContext(getServletContext());
//从容器中获取某个bean
Pojo pojo = app.getBean("pojo", Pojo.class);
pojo.fun();
}
}

在Spring-web项目中使用Spring-jdbc

Spring提供了一套自己的JDBC解决方案，相较于自己写的JDBC，省去了繁琐的过程(获取连接、关闭)，

简化了对数据库的操作。

Spring-jdbc后续会用其他持久层框架代替，如MyBatis、JPA。

1.引入相关依赖

当前案例中核心的依赖是 spring-jdbc

<!--servlet-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>
<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.31</version>
</dependency>
<!--jstl-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<!--spring容器-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.23</version>
</dependency>
<!--web集成spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.3.23</version>
</dependency>
<!-- spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.3.23</version>
</dependency>

2.创建包结构(controller、service、dao、entity)，创建实体类

3.在Spring配置文件中配置数据源和JDBC模板

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--扫描使用了Spring注解的根包-->
<context:component-scan base-package="com.hqyj.springweb">
</context:component-scan>
<!--配置数据源-->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource"
id="dataSource">
<!--配置MySQL驱动-->
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver">
</property>
<!--配置MySQL地址-->
<property name="url" value="jdbc:mysql://localhost:3306/gamedb?
serverTimezone=Asia/Shanghai"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
<!--配置JDBC模板-->
<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
<!--设置要操作的数据源-->
<property name="dataSource" ref="dataSource"></property>
</bean>
</beans>

JDBCTemplate常用方法

SpringMVC

在Web阶段中，控制层是由Servlet实现，传统的Servlet，需要创建、重写方法、配置映射。使用时极不

方便，SpringMVC可以替换Servlet。

SpringMVC是Spring框架中位于Web开发中的一个模块，是Spring基于MVC设计模式设计的轻量级Web

框架。

SpringMVC提供了一个DispatcherServlet的类，是一个Servlet。它在指定映射(通常设置为/或*.do)接

收某个请求后，调用相应的模型处理得到结果，再通过视图解析器，跳转到指定页面，将结果进行渲

染。

原理大致为：配置SpringMVC中的DispatcherServlet，将其映射设置为/或*.do。

如果是/表示一切请求先经过它，如果是*.do表示以.do结尾的请求先经过它，

它对该请求进行解析，指定某个Controller中的某个方法，这些方法通常返回一个字符串，

这个字符串是一个页面的名称，再通过视图解析器，将该字符串解析为某个视图的名称，跳转到该视图

页面。

使用SpringMVC

1.创建webapp项目

修改web.xml版本为4.0

创建java和resources目录

创建包结构

2.添加依赖

<!-- spring-webmvc -->
<!-- 这个依赖会包含spring-web和spring-context -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.3.23</version>
</dependency>

3.配置初始化Spring

在resources目录下创建Spring配置文件application.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--设置扫描使用了注解的根包-->
<context:component-scan base-package="com.hqyj.springmvc">
</context:component-scan>
</beans>

在web.xml中使用监听器ContextLoaderListener初始化Spring

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
version="4.0">
<!--配置全局监听器初始化Spring-->
<listener>
<listenerclass>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!--定义全局参数读取Spring配置文件-->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:application.xml</param-value>
</context-param>
</web-app>

4.配置SpringMVC

在resources目录下创建配置SpringMVC的配置文件springmvc.xml

配置要扫描的控制层类所在的包名

配置内部资源视图解析器以及视图路径的前后缀

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--扫描控制层所在的包-->
<context:component-scan base-package="com.hqyj.springmvc.controller">
</context:component-scan>
<!--配置内部资源视图解析器-->
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<!--最终控制层跳转的页面所在的路径及页面自身后缀名-->
<!--jsp页面不建议直接通过浏览器访问。在WEB-INF目录下在资源，无法通过浏览器直接
方法，所以将jsp保存在WEB-INF目录下，最好创建一个pages-->
<property name="prefix" value="/WEB-INF/pages/"></property>
<!--现阶段使用jsp输出数据，所以后缀为.jsp-->
<property name="suffix" value=".jsp"></property>
</bean>
</beans>

在web.xml中配置DispatcherServlet

将该Servlet的请求映射设置为/，表示所有请求都会访问该Servlet，由该Servlet再进行分发

<!--配置DispatcherServlet-->
<servlet>
<servlet-name>dispatcherServlet</servlet-name>
<servletclass>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<!--设置该Servlet的初始化参数，用于读取SpringMVC配置文件-->
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>dispatcherServlet</servlet-name>
<!--设置该servlet的映射为/或*.do-->
<url-pattern>/</url-pattern>
</servlet-mapping>

5.在WEB-INF目录下创建一个pages目录，在其中创建一welcome.jsp页面

通常jsp页面不允许被浏览器直接访问，需要保存在WEB-INF目录下

6.编写控制层代码

在controller包下创建一个类，加上@Controller注解

该类中定义的方法方法加入@RequestMapping()注解表示访问该方法的映射

该类中定义的方法返回值通常为字符串，表示某个页面的名称，也可以是另一个controller中的方

法映射名

package com.hqyj.springmvc.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
//加入@Controller注解表示该类是一个控制层类，替换之前的servlet
@Controller
//该注解如果只设置请求映射，直接填字符串
@RequestMapping("/first")
public class HelloController {
//该注解如果还有其他参数要设置，路径用path赋值
@RequestMapping(path="/hello")
public String hello(){
//返回的字符串是某个页面的名称或另一个控制层中方法的请求映射
return "welcome";
}
}

SpringMVC相关注解

@Controller

只能写在类上，表示该类属于一个控制器

@RequestMapping("/请求映射名")/@RequestMapping(value="/请求映射

名")/@RequestMapping(path="/请求映射名")

该注解可以写在类或方法上。写在类上用于区分功能模块，写在类上用于区分具体功能

默认写一个属性或value或path后的值，都表示访问该类或该方法时的请求映射

@RequestMapping(value="/请求映射

名",method=RequestMethod.GET/POST/PUT/DELETE)

method属性表示使用哪种请求方式访问该类或该方法

如果注解中不止一个属性，每个属性都需要指定属性名

@GetMapping("/请求映射名")相当于@RequestMapping(value="/请求映射

名",method=RequestMethod.GET)

post、put、delete同理

@GetMapping只能写在方法上

@PathVariable

该注解写在某个方法的某个形参上

通常配合@RequestMapping("/{path}")获取请求时传递的参数

@RequestMapping("/{path}")
public String fun(@PathVariable("path") String pageName){
return pageName;
}
//当前方法如果通过"localhost:8080/项目名/hello"访问，就会跳转到hello.jsp
//当前方法如果通过"localhost:8080/项目名/error"访问，就会跳转到error.jsp
//映射中的/{path}就是获取路径中的hello或error，将其赋值给形参
//通常用于跳转指定页面

@RequestParam(value="传递的参数名",defaultValue ="没有传递参数时的默认值")

该注解写在某个方法的某个参数上

用于获取提交的数据，可以设置默认值在没有提交数据时使用

ORM

Object Relational Mapping 对象关系映射

创建Java类的对象，将其属性和数据库表中的字段名之间构建映射关系。

这样通过操作该类创建的一个对象，就能操作数据库中对应的数据表。

ORM框架就是对象关系映射框架，用于简化JDBC。

主流的ORM框架有Hibernate、JPA、MyBatis、MyBatisPlus等

MyBatis

一个半自动化的ORM框架。原本叫做ibatis，后来升级改名为MyBatis。

MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。

使用XML文件或注解的形式，将SQL语句映射为持久层(dao层)中的方法。

特点

方便

简化JDBC

解除SQL语句与业务代码的耦合

sql和java代码分离，sql写在xml文件中，方便扩展维护。

支持动态SQL

不同的情况下构造不同的SQL

主流

SSM中的M

SSM项目搭建

整体流程

1.创建基于Maven的webapp项目

2.修改web.xml版本为4.0，创建java、resoureces目录、项目包结构、web-inf下的页面目录

3.导入依赖

spring-webmvc

mybatis

mybatis-spring

mysqldruid

spring-jdbc

jstl

4.配置Spring

创建application.xml

扫描项目根包

配置web.xml

设置全局参数： <context-param> ，读取application.xml文件

设置全局监听器：ContextLoaderListener，初始化Spring容器

5.配置SpringMVC

创建springmvc.xml

扫描控制层所在包

设置内部资源视图解析器：InternalResourceViewResolver，设置前后缀

配置web.xml

设置请求分发器：DispatcherServlet，在其中读取springmvc.xml配置文件

过滤器解决请求中文乱码：CharacterEncodingFilter

6.配置MyBatis

创建mybatis-config.xml(官网模板)

在application.xml中注入

数据库连接池Druid：DruidDataSource

SQL会话工厂：SqlSessionFactoryBean

映射扫描配置器：MapperScannerConfigurer

7.执行sql语句

创建dao层接口，定义方法

在resoureces下创建mapper目录创建sql映射文件xx.xml(官网模板)，在其中定义sql语句

SSM项目搭建补充

通过db.properties文件保存连接数据库的信息

.properties文件称为属性文件，其中的数据以键值对(key=value)的形式保存

在resources目录下新建db.properties文件

DB_DRIVER_CLASS_NAME=com.mysql.cj.jdbc.Driver
DB_URL=jdbc:mysql://localhost:3306/bookdb?serverTimezone=Asia/Shanghai
DB_USERNAME=root
DB_PASSWORD=root

在application.xml中读取properties文件

<!--读取properties文件-->
<context:property-placeholder location="classpath:db.properties">
</context:property-placeholder>

读取时使用EL表达式访问其中的键

<!--Druid数据源DruidDataSource-->
<bean class="com.alibaba.druid.pool.DruidDataSource" id="druidDataSource">
<property name="driverClassName" value="${DB_DRIVER_CLASS_NAME}">
</property>
<property name="url" value="${DB_URL}"></property>
<property name="username" value="${DB_USERNAME}"></property>
<property name="password" value="${DB_PASSWORD}"></property>
</bean>

MyBatis配置文件常用设置

<?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>
<!--设置-->
<settings>
<!--开启驼峰命名映射-->
<setting name="mapUnderscoreToCamelCase" value="true"/>
<!--开启SQL日志-->
<setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
</configuration>

在SpringMVC中，让某个控制层中的方法返回JSON格式的数据

添加依赖

<!--jackson：将数据转换为JSON格式-->
<dependency>
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
<version>2.14.2</version>
</dependency>

@ResponseBody注解

该注解可以加在类或方法上

如果加在方法上，表示该方法的返回值类型为JSON格式

如果加在类上，表示该类中的所有方法的返回值类型为JSON格式

SSM项目中使用Ajax

ajax依赖于jquery，所以先保证页面中存在jquery.js。

$.ajax({
url:"访问地址",
data:{
"提交的参数名":"实际值",
"提交的参数名":"实际值"
},
type:"get/post",
success:function(res){
//成功后的回调函数,res为访问后的结果，必须是json格式
}
});

在前端页面中使用ajax访问controller时，controller的返回值必须是一个JSON格式的字符串。

所以controller中的方法上要加入@ResponseBody注解

在SpringMVC中使用Session

方式一：@SessionAttributes注解

由于SSM项目中，没有使用servlet，所以不能通过request.getSession()方法来获取session对象。

在控制器Controller中，在类上加入@SessionAttributes注解

@SessionAttributes({"参数1","参数2"})表示在session中保存两个参数

再在某个方法中，通过Model对象调用addAttribute("参数1",对象)方法将指定对象保存到session中

方式二：HttpSession参数

给项目添加javax.servlet.api依赖，给controller中某个方法添加HttpSession参数后，获取session使用

<!--如果要使用servlet相关内容-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>

使用和销毁

@Controller
@RequestMapping("/sysAdmin")
//如果要将数据保存到session中，先使用该注解定义session中的参数名
@SessionAttributes({"sysAdmin"})
public class SysAdminController {
@Autowired
SysAdminService sysAdminService;
@RequestMapping("/login")
@ResponseBody
public SysAdmin login(SysAdmin sysAdmin,HttpSession session) {
SysAdmin login = sysAdminService.login(sysAdmin);
//将登录成功的对象保存到session中
session.setAttribute("sysAdmin",login);
return login;
}
/*登出时销毁session*/
@RequestMapping("/logout")
public String logout(HttpSession session) {
session.invalidate();
return "redirect:/login";
}
}

拦截器

每次请求controller时，都要经过的一个类。

当一个项目中有过滤器、拦截器和controller时的执行流程

实现过程

1. 导入servlet依赖

<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.1</version>
</dependency>

2.自定义一个类，实现拦截器HandlerInterceptor接口

其中有三个default方法可以重写

preHandle

在发送请求后，DispatcherServlet解析控制器中某个RequestMapping之前执行的方法

该方法返回true时，请求才能继续

postHandle

在preHandle方法返回值为true后执行

在DispatcherServlet解析控制器中某个RequestMapping之后执行

afterCompletion

在preHandle方法返回true后执行

在解析视图后执行的方法

这里只需重写preHandle方法即可

package com.hqyj.ssm02.interceptor;
import org.springframework.web.servlet.HandlerInterceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/*
* 自定义拦截器，用户拦截未登录时的请求
* */
public class MyInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse
response, Object handler) throws Exception {
String requestURI = request.getRequestURI();
//登录成功后，会在session中保存一个名为sysAdmin的对象
Object sysAdmin = request.getSession().getAttribute("sysAdmin");
//如果有对象，说明登录成功，可以放行return true
if(sysAdmin!=null){
return true;
}else{
response.sendRedirect(request.getContextPath()+"/login");
}
System.out.println(requestURI+"试图访问，拦截成功");
return false;
}
}

3.在springmvc.xml中配置拦截器

<!--配置拦截器们-->
<mvc:interceptors>
<!--配置某个拦截器-->
<mvc:interceptor>
<!--设置要拦截的请求，这里的/**表示拦截一切请求-->
<mvc:mapping path="/**"/>
<!--设置不拦截的请求-->
<!--放行登录和注册页-->
<mvc:exclude-mapping path="/login"/>
<mvc:exclude-mapping path="/register"/>
<!--放行静态资源-->
<mvc:exclude-mapping path="/static/**"/>
<!--放行用户模块-->
<mvc:exclude-mapping path="/sysAdmin/**"/>
<!--注入指定的拦截器-->
<bean class="com.hqyj.ssm02.interceptor.MyInterceptor"></bean>
</mvc:interceptor>
</mvc:interceptors>

SpringBoot

Spring推出的一个Spring框架的脚手架。

不是一个新的框架，而是搭建Spring相关内容框架的平台。

它省去了Spring、SpringMVC项目繁琐的配置过程，让开发变得更加简单。

本质还是Spring+SpringMVC，可以搭配其他的ORM框架，如MyBatis、MyBatisPlus、JPA、Hibernate

等。

特点

内置了Tomcat服务器，不需要部署项目到Tomcat中

内置了数据源Hikari

减少了jar文件依赖的配置

SpringBoot中的配置文件可以使用yml格式文件，代替properties或xml

Lombok

用于简化实体类中模板代码的工具

使用

添加依赖，可以在创建的项目的时候选择，也可以中途添加

<!--Lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.24</version>
<scope>provided</scope>
</dependency>

在某个实体类上添加注解

SpringBoot+MyBatis

1.创建好SpringBoot项目

最好在创建的时候选择以下依赖

spring-web(必选)

lombok

spring-devtools

springboot集成mybatismysql驱动

2.在pom.xml中添加mybatis集成SpringBoot依赖和数据库驱动

<!--mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>8.0.31</version>
</dependency>
<!--springboot集成MyBatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>2.3.0</version>
</dependency>

3.在springboot配置文件application.properties中

#注释
#.properties文件称为属性文件，数据以键值对"键=值"的形式保存
#设置项目启动端口号
#server.port=9090
#设置项目上下文路径
#server.servlet.context-path=/springbootday1
#mybatis相关配置
#开启驼峰命名映射
mybatis.configuration.map-underscore-to-camel-case=true
#打印sql语句
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
#扫描mybatis的sql映射文件(将mapper.xml文件保存在resources目录下的mapper目录下)
mybatis.mapper-locations=classpath:mapper/*.xml
#数据库信息
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/gamedb?
serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

4.根据数据表创建实体类、dao层接口、service、controller

5.在SpringBoot的启动类上，加入@MapperScan注解，扫描dao层所在根包

@SpringBootApplication
//扫描dao层所在的根包
@MapperScan("com.hqyj.first.dao")
public class FirstApplication {
public static void main(String[] args) {
SpringApplication.run(FirstApplication.class, args);
}
}

启动项目，按自定的项目上下文路径和端口号访问某个controller中的方法

MyBatisPlus

官网简介 | MyBatis-Plus (baomidou.com)

MyBatis-Plus (简称 MP)是一个MyBatis的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开

发、提高效率而生。

只需简单的配置，就能实现对单表的CURD。

其核心有两个接口：BaseMapper和IService

BaseMapper中封装了大量数据访问层的方法

IServcie中封装了大量业务流程层的方法

SpringBoot+MyBatisPlus

1.创建SpringBoot项目

创建时勾选依赖

devtools

lombok

spring-web

mysql-driver

2.导入SpringBoot集成MyBatisPlus依赖

<!-- SpringBoot集成MyBatisPlus -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.5.3.1</version>
</dependency>

3.配置application.properties文件

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/gamedb?
serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root
# 开启sql日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl
# 无需加入开启驼峰命名映射，MyBatisPlus默认使用驼峰命名进行属性-字段映射
#mybatis-plus.configuration.map-underscore-to-camel-case=true

4.根据数据表创建实体类

实体类的属性名命名方式：

MyBatisPlus默认使用驼峰命名对字段和属性进行映射。如将字段stu_name对应的属性写为

stuName

如果字段名和属性名不一致，在属性名上加入@TableField(value = "字段名")

主键字段对应的属性，需要加入@TableId注解，其type属性表示主键生成策略

@TableId(type = IdType.AUTO)表示主键自增，在数据库也要将主键设置为自增

@TableId(type = IdType.ASSIGN_ID)//IdType.ASSIGN_ID表示使用"雪花算法"(根据时间和机

器特征码)生成一个id

@TableId(type = IdType.ASSIGN_UUID)//IdType.ASSIGN_UUID表示使用UUID生成一个随机

字符串id

BaseMapper接口中的常用方法

IService接口中的常用方法