文章目录

页面技术
一、Spring框架
- 1. 三层体系架构
- 2. Spring的核心
- 3. Spring 的Bean中主要的装配方式
- - （1）基于XML的装配：
  - （2）基于Annotation的装配：
  - （3）自动装配：
- 4. Spring框架的优点如下：
- 5. Spring框架包：
- 6. ApplicationContext容器
- 7. SpringIOC应用示例核心代码：
二、SpringJDBCTemplate
- 1. 在Spring的配置文件中配置JDBC
- 2. JdbcTemplate类
- 3. dataSource配置
- 4. Spring 为JDBC提供了三个模板类供选择：
- 5. SpringJDBCTemplate应用示例核心代码：
三、SpringMVC
- 1. 典型的Web层框架包括：
- 2. Spring MVC的特点。
- 3. Spring MVC主要有如下优点：
- 4. Spring MVC框架的工作流程如下：
- 5. 在web.xml中，配置Spring MVC的前端控制器DispatcherServlet
- 6. 控制器方法的返回值类型
- 7. @Controller注解在使用时可分为如下两步：
- 8. SpringMVC框架下请求处理方法的参数类型：
- 9. SpringMVC中获取输入值的方式主要有：
- 10. SpringMVC中对用户的响应方式主要有：
- 11. @RequestParam注解
- 12. 在使用包装POJO类型数据绑定时
- 13. JSON数据交互时，主要使用的两个注解@RequestBody和@ResponseBody
- 14. JSON对象的数组结构
- 15. RESTful
- 16. @PathVariable("id")注解
- 17. Spring MVC的文件上传
四、拦截器
- 1. HandlerInterceptor接口中有3个方法：
- 2. 拦截器类定义
- 3. 单个/多个拦截器工作
- 4. 拦截器的配置和执行流程：
- - 单个拦截器执行流程：
  - 多个拦截器执行流程：
- 5. 定时器的作用：
五、Mybatis
- 1. Hibernate和MyBatis
- - （1）Hibernate：
  - （2）MyBatis：
- 2. MyBatis核心组件：
- 3. MyBatis框架的工作执行流程如下：
- 4. `<sql>`元素
- 5. MyBatis核心对象SqlSessionFactory的获取方式：
- - MyBatis使用过程：
- 6. `<mapper>`元素
- 7. mybatis中映射文件include标签应用
- 8. MyBatis映射文件中`<mapper>`元素
- 9. MyBatis映射文件中`<insert>`元素
- 10. 根据MyBatis的映射文件编写Mapper接口过程中涉及的关键问题如下：
- 11. MyBatis配置XML文件结构如下
六、SSM框架整合
- 1. MyBatis与Spring整合所需JAR包主要包括
- 2. MapperFactoryBean与MapperScannerConfigurer
- 3. 三大框架整合
- 4. SSM框架整合时，Spring配置文件中配置信息主要包括：
- 5. 配置MyBatis中的映射器——采用MapperScannerConfigurer类
- 6. 在进行Spring与MyBatis整合时
- 7. SSM框架整合
七、SpringAOP和事务控制
- 1. AOP(Aspect-Oriented Programming,面向切面编程)：
- 2. AOP框架：Spring AOP和AspectJ。
- 3. AspectJ框架中注解
- 4. Spring的配置文件中的`<beans>`元素
- 5. AOP术语中Advice
- 6. Spring的声明式事务管理的两种实现方式

页面技术

提示：这里可以添加本文要记录的大概内容：

JSP（web服务器端技术）、JSTL标签库、EL表达式、bootstrap页面模板（静态html、CSS、JS））
采用传统开发模式时，页面需要用到jsp技术（JSTL标签库、EL表达式）。

前后端分离的开发模式，页面使用VUE框架，后端服务使用SSM或者是SpringBoot。

提示：以下是本篇文章正文内容，下面案例可供参考

一、Spring框架

1. 三层体系架构

在实际开发中，通常服务器端在采用分层方式进行架构。三层体系架构，分别为表示层(Web层，包括控制层，使用SpringMVC框架)、业务逻辑层(Service，使用Spring框架)、持久层(数据访问层，Dao，使用Mybatis框架)， Spring对每一层都提供了技术支持。

2. Spring的核心

Spring的核心是控制反转（IoC： Inverse of Control ）和面向切面编程（AOP： Aspect Oriented Programming ）。
在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。

IoC的全称是Inversion of Control，中文名称为控制反转。控制反转就是指在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。这样，控制权由应用代码转移到了Spring容器，控制权发生了反转。

DI的全称是Dependency Injection，中文称之为依赖注入。它与控制反转（IoC）的含义相同，只不过这两个称呼是从两个角度描述的同一个概念。从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

3. Spring 的Bean中主要的装配方式

Spring 的Bean中主要包含三种装配方式，分别为基于XML的装配，基于Annotation的装配和自动装配，这三种装配方式的用法如下：

（1）基于XML的装配：

Spring提供了2种基于XML的装配方式：设值注入（Setter Injection）和构造注入（Constructor Injection）。
一种是属性setter方法注入（或设值注入），另一种是构造方法注入。属性setter方法注入是指IoC容器使用setter方法来注入被依赖的实例。通过调用无参构造器或无参静态工厂方法实例化Bean后，调用该Bean的setter方法，即可实现基于setter方法的依赖注入。属性setter方法注入的必备条件如下：

Bean类必须有一个无参构造方法

Bean类必须为属性提供setter方法

在配置文件中，使用<property>元素来为每个属性注入值
设置注入中的Bean类必须提供一个默认的无参构造方法，同时必须为需要注入的属性提供对应的setter方法。使用设值注入时，在Spring配置文件中，需要使用<bean>元素的子元素<property>来为每个属性注入值。使用构造注入时，在配置文件里，需要使用<bean>元素的子元素<constructor-arg>来定义构造方法的参数，可以使用其value属性（或子元素）来设置该参数的值。
构造方法注入是指IoC容器使用构造方法来注入被依赖的实例。基于构造方法的依赖注入通过调用带参数的构造方法来实现，每个参数代表着一个依赖。要求必须满足如下条件：

Bean类必须提供有参构造方法

配置文件中，使用元素来为参数注入值

（2）基于Annotation的装配：

使用基于Annotation的装配时，首先需要使用@Repository、@Service与@Controller分别对实现类进行标注，然后用@Autowired或@Resource注解对注入的Bean的属性进行标注，最后在Spring的配置文件中，通过<context:annotation-config />来开启注解处理器，或使用<context:component-scan base-package="Bean所在的包路径"/>的配置方式即可实现Annotation的装配。

@Controller通常作用在控制层，用于将控制层的类标识为Spring中的Bean。

@Service通常作用在业务层，用于将业务层的类标识为Spring中的Bean。

@Repository通常作用在数据持久层（或数据访问层，DAO层），用于将数据持久层的类标识为Spring中的Bean。

@Autowired或@Resource注解对注入的Bean的属性进行标注，用于将实例化后对象注入到Bean的属性中，实现依赖注入。

（3）自动装配：

在<bean>元素中使用 autowire属性，并将其属性值设置为 byName或者 byType即可实现自动装配。

4. Spring框架的优点如下：

（1）非侵入式设计：Spring是一种非侵入式（non-invasive）框架，它可以使应用程序代码对框架的依赖最小化。
（2）方便解耦、简化开发：Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护工作都交给Spring容器管理，大大的降低了组件之间的耦合性。
（3）支持AOP：Spring提供了对AOP的支持，它允许将一些通用任务，如安全、事务、日志等进行集中式处理，从而提高了程序的复用性。
（4）支持声明式事务处理：只需要通过配置就可以完成对事务的管理，而无需手动编程。
（5）方便程序的测试：Spring提供了对Junit4的支持，可以通过注解方便的测试Spring程序。
（6）方便集成各种优秀框架：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持。
（7）降低了Java EE API的使用难度：Spring对Java EE开发中非常难用的一些API（如：JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

5. Spring框架包：

Spring开发所需的jar包分为两个部分： Spring框架4个核心基础包和一个第三方依赖包。

spring-core-4.3.6.RELEASE.jar
包含Spring框架的核心工具类，Spring其它组件都要用到这个包里的类。

spring-beans-4.3.6.RELEASE.jar
所有应用都要用到的JAR包，它包含访问配置文件、创建和管理Bean以及进行控制反转或者依赖注入操作相关的所有类。

spring-context-4.3.6.RELEASE.jar
提供了在基础IoC功能上的扩展服务，还提供了许多企业级服务的支持

spring-expression-4.3.6.RELEASE.jar
定义了Spring的表达式语言。

在使用Spring开发时，除了要使用自带的JAR包外，Spring的核心容器还需要依赖一个第三方包commons.logging的JAR包。

6. ApplicationContext容器

通常在Java项目中，通常会通过ClassPathXmlApplicationContext类来实例化ApplicationContext容器的方式，而在Web项目中，ApplicationContext容器的实例化工作会交由Web服务器来完成。

7. SpringIOC应用示例核心代码：

main方法：

public class Test {

	public static void main(String[] args) {
		ApplicationContext context = 
				new ClassPathXmlApplicationContext("applicationContext.xml");
		
		UserService userService = (UserService) context.getBean("userService");
		User user = new User();
		user.setId("11111");
		user.setName("zhangsan22222");
		userService.addUser(user);
	}

}

applicationContext.xml

<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-3.0.xsd">
    <!--配置bean,配置后该类由spring管理-->  
	<bean id="userService" class="spring.ioc.service.UserService">
	    <!--依赖注入,配置当前类中相应的属性-->  
	    <!-- <property>标签中的name就是UserService类中的userDao属性名，ref指下面<bean name="userDao"...>，这样其实是spring将UserDaoImp对象实例化并且调用UserService的setUserDao方法将UserDao注入 -->
		<property name="userDao" ref="userDaoImp"></property>
	</bean>
	<!—配置bean ，,配置后该类由spring管理-->
	<bean id="userDaoImp" class="spring.ioc.dao.imp.UserDaoImp"></bean>

</beans>

UserService.java

public class UserService {
	public UserDao userDao;
	public UserDao getUserDao() {
		return userDao;
	}
	public void setUserDao(UserDao userDao) {
		this.userDao = userDao;
	}
	public void addUser(User user){
		userDao.addUser(user);
	}
}

UserDaoImp.java

public class UserDaoImp implements UserDao{
	public void addUser(User user){
		System.out.println("添加了一个用户，姓名是"
	        +user.getName()+user.getId());
	}
}

二、SpringJDBCTemplate

1. 在Spring的配置文件中配置JDBC

在Spring的配置文件中配置JDBC时，需要定义了三个Bean，分别是dataSource、jdbcTemplate和需要注入类的Bean。在定义jdbcTemplate时，需要将dataSource注入到jdbcTemplate中，而其他需要使用jdbcTemplate的Bean，也需要将jdbcTemplate注入到该Bean中，这样配置完成后，Spring JDBC就可以使用了。

2. JdbcTemplate类

Spring框架提供了JdbcTemplate类，该类是Spring框架数据抽象层的基础。JdbcTemplate类是Spring JDBC的核心类。JdbcTemplate的直接父类是抽象类JdbcAccessor，实现了接口JdbcOperations。
在JdbcTemplate类中，提供了大量的更新和查询数据库的方法，使用这些方法来操作数据库，其常用的方法包括execute()、update()和query()。
其中execute()方法能够完成执行SQL语句的功能，update()方法可以完成插入、更新和删除数据的操作，query()方法可以用来处理各种对数据库表的查询操作。

3. dataSource配置

dataSource配置，即JDBC连接数据库时需要4个基本属性，包括有driverClassName、url、username和password。
在这里插入图片描述

4. Spring 为JDBC提供了三个模板类供选择：

JdbcTemplate：最基本的Spring JDBC模板，支持简单的JDBC数据访问功能及基于索引参数的查询。使用占位符（？）绑定参数。

NamedParameterJdbcTemplate：该模板查询时可以将值以命名参数（：参数名）的形式绑定到SQL中，而不是使用简单的索引参数。

SimpleJdbcTemplate：该模板利用Java5的一些特性如自动装箱、泛型以及可变参数列表来简化JDBC模板的使用。

5. SpringJDBCTemplate应用示例核心代码：

Main方法：

    public static void main( String[] args ){
    	Test test = new Test();
    	UserAction userAction = test.getController();
    	test.testAdd(userAction);
//    	test.testFindNumbers(userAction);
//    	test.testFindNameById(userAction);
//    	test.testFindUser(userAction);
//    	test.testFindAll(userAction);
//    	test.testFindMapUser(userAction);
//    	test.testFindMapAll(userAction);
    }
    public UserAction getController(){
    	ApplicationContext context = 
        		new ClassPathXmlApplicationContext("config/applicationContext.xml");
    	UserAction userAction = (UserAction) context.getBean("userAction");
    	return userAction;
    }
    
    public void testAdd(UserAction userAction){
    	User user  =new User();
    	user.setId(7);
    	user.setName("张三");
    	user.setAge(20);
    	userAction.add(user);
    }
    
    public void testFindNumbers(UserAction userAction){
    	int numbers = userAction.findNumbers();
    	System.out.println("findNumbers方法的查询结果：");
    	System.out.println("共有"+numbers+"个用户！");
    }
    
    public void testFindNameById(UserAction userAction){
    	String name = userAction.findNameById(1);
    	System.out.println("findNameById方法的查询结果：");
    	System.out.println("学号为1的学生的姓名为："+name);
    }
    
    public void testFindUser(UserAction userAction){
    	System.out.println("findUser方法的查询结果：");
    	User user  = userAction.findById(1);
    	System.out.println("id："+user.getId()
    	+",name:"+user.getName()
    	+",age:"+user.getAge());
    }

    public void testFindAll(UserAction userAction){
    	List<User> users  = userAction.findAll();
    	System.out.println("findAll方法的查询结果：");
    	for(User user:users){
	    	System.out.println("id："+user.getId()
	    	+",name:"+user.getName()
	    	+",age:"+user.getAge());
    	}
    }

    public void testFindMapUser(UserAction userAction){
    	System.out.println("findMapUser方法的查询结果：");
    	Map<String,Object> user  = userAction.findMapById(1);
    	System.out.println("id："+user.get("id")
    	+",name:"+user.get("name")
    	+",age:"+user.get("age"));
    }

    public void testFindMapAll(UserAction userAction){
    	System.out.println("findMapAll方法的查询结果：");
    	List<Map<String,Object>> users  = userAction.findAllMap();
    	for(Map<String,Object> user:users){
        	System.out.println("id："+user.get("id")
        	+",name:"+user.get("name")
        	+",age:"+user.get("age"));
    	}
    }
}

applicationContext.xml

<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-3.0.xsd">

	<bean id="userAction" class="action.UserAction">
		<property name="userService" ref="userService" />
	</bean>

	<bean id="userService" class="service.UserService">
		<property name="userDao" ref="userDao" />
	</bean>
	<bean id="dataSource1"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">

		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/spring" />
		<property name="username" value="root" />
		<property name="password" value="root" />
	</bean>
	<bean id="userDao" class="dao.UserDao">
		<property name="jdbcTemplate" ref="jdbcTemplate1" />
		<property name="npjt" ref="namedParameterJdbcTemplate" />
	</bean>
	<bean id="jdbcTemplate1" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource1" >
		</property>
	</bean>
	<!-- NamedParameterJdbcTemplate配置 -->
    <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
		<constructor-arg ref="jdbcTemplate1" />
	</bean>

</beans>

UserAction.java

public class UserAction {
	private UserService userService;

	public UserService getUserService() {
		return userService;
	}

	public void setUserService(UserService userService) {
		this.userService = userService;
	}

	public void add(User user) {
		userService.add(user);
	}

	public String findNameById(int id) {
		return userService.findNameById(id);
	}

	public int findNumbers() {
		return userService.findNumbers();
	}

	public List<User> findAll() {
		return userService.findAll();
	}

	public User findById(int id) {
		return userService.findById(id);
	}

	public Map<String, Object> findMapById(int id) {
		return userService.findMapById(id);
	}

	public List<Map<String, Object>> findAllMap() {
		return userService.findAllMap();
	}
}

UserService.java

public class UserService {
	private UserDao userDao;

	public UserDao getUserDao() {
		return userDao;
	}

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

	public void add(User user) {
		userDao.add(user);
	}

	public String findNameById(int id) {
		return userDao.findNameById(id);
	}

	public int findNumbers() {
		return userDao.findNumbers();
	}

	public List<User> findAll() {
		return userDao.findAll();
	}

	public User findById(int id) {
		return userDao.findById(id);
	}

	public Map<String, Object> findMapById(int id) {
		return userDao.findMapById(id);
	}

	public List<Map<String, Object>> findAllMap() {
		return userDao.findAllMap();
	}
}

UserDao.java

public class UserDao {
	private JdbcTemplate jdbcTemplate;
 
	private NamedParameterJdbcTemplate npjt;
	
	public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}

	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}
	public NamedParameterJdbcTemplate getNpjt() {
		return npjt;
	}

	public void setNpjt(NamedParameterJdbcTemplate npjt) {
		this.npjt = npjt;
	}
	
	public void add(User user){
		String sql = "insert into CUSTOMERS values(?,?,?)";
		jdbcTemplate.update(sql,
				new Object[]{user.getId(),user.getName(),user.getAge()});
		
		/*NamedParameterJdbcTemplate使用：Map传参*/
		String sql1="insert into CUSTOMERS (id,name,age) values (:id,:name,:age)";
		Map<String,Object> paramMap=new HashMap<String,Object>();
		paramMap.put("id", 1);
		paramMap.put("age", "20");
		paramMap.put("name", "npjt");
		paramMap.put("sex", "女");
		npjt.update(sql1, paramMap);
		
		/*NamedParameterJdbcTemplate使用：实体类（User）传参*/
		SqlParameterSource paramSource=new BeanPropertySqlParameterSource(user);
		npjt.update(sql1, paramSource);
	}

	public String findNameById(int id) {
		String sql = "SELECT NAME FROM CUSTOMERS WHERE id = ?";
		String name = (String) jdbcTemplate.queryForObject(sql, new Object[] { id }, String.class);
		return name;
	}

	public int findNumbers() {
		String sql = "SELECT COUNT(*) FROM CUSTOMERS";
		int total = jdbcTemplate.queryForObject(sql,Integer.class);
		return total;
	}

	public List<User> findAll() {
		String sql = "SELECT * FROM CUSTOMERS";
		//List<Customer> customers = jdbcTemplate.query(sql, new BeanPropertyRowMapper(Customer.class));
		List<User> customers = jdbcTemplate.query(sql, new CustomerRowMapper());
		return customers;
	}

	public User findById(int id) {
		String sql = "SELECT * FROM CUSTOMERS WHERE id = ?";
		User customer = (User) jdbcTemplate.queryForObject(sql,
				new Object[] { id },new CustomerRowMapper());
		return customer;
	}
	
	public Map<String,Object> findMapById(int id){
		String sql = "SELECT * FROM CUSTOMERS WHERE id = ?";
		return jdbcTemplate.queryForMap(sql,new Object[]{id});
	}
	
	public List<Map<String,Object>> findAllMap(){
		String sql = "SELECT * FROM CUSTOMERS";
		return jdbcTemplate.queryForList(sql);
	}
}

三、SpringMVC

1. 典型的Web层框架包括：

Struts1
Web work
Struts2
Spring MVC

Spring MVC是Spring提供的一个实现了Web MVC设计模式的轻量级Web框架。采用工厂模式。它与Struts2框架一样，都属于MVC框架，但其使用和性能等方面比Struts2更加优异。SpringMVC项目中必须添加的JAR包包括：4个核心JAR包、commons-logging的JAR以及两个web相关的JAR（spring-web和spring-webmvc的JAR包）。

2. Spring MVC的特点。

（1）是Spring框架的一部分，可以方便的利用Spring所提供的其他功能。
（2）灵活性强，易于与其他框架集成。
（3）提供了一个前端控制器DispatcherServlet，使开发人员无需额外开发控制器对象。
（4）可自动绑定用户输入，并能正确的转换数据类型。
（5）内置了常见的校验器，可以校验用户输入。如果校验不能通过，那么就会重定向到输入表单。
（6）支持国际化。可以根据用户区域显示多国语言。

3. Spring MVC主要有如下优点：

4. Spring MVC框架的工作流程如下：

（1）用户通过浏览器向服务器发送请求，请求会被Spring MVC的前端控制器DispatcherServlet所拦截。
（2）DispatcherServlet拦截到请求后，会调用HandlerMapping处理器映射器。
（3）处理器映射器根据请求URL找到具体的处理器，生成处理器对象及处理器拦截器（如果有则生成）一并返回给DispatcherServlet 。
（4）DispatcherServlet会通过返回信息选择合适的HandlerAdapter（处理器适配器）。
（5）HandlerAdapter会调用并执行Handler（处理器），这里的处理器指的就是程序中编写的Controller类，也被称之为后端控制器。
（6）Controller执行完成后，会返回一个ModelAndView对象，该对象中会包含视图名或包含模型和视图名。
（7）HandlerAdapter将ModelAndView对象返回给DispatcherServlet 。
（8）DispatcherServlet会根据ModelAndView对象选择一个合适的ViewReslover（视图解析器）。
（9）ViewReslover解析后，会向DispatcherServlet中返回具体的View（视图）。
（10）DispatcherServlet对View进行渲染（即将模型数据填充至视图中）。
（11）视图渲染结果会返回给客户端浏览器显示。

5. 在web.xml中，配置Spring MVC的前端控制器DispatcherServlet

在这里插入图片描述

如果没有通过<init-param>元素配置，应用程序会默认到WEB-INF目录下寻找如下方式命名的配置文件：servletName-servlet.xml。servletName指的是部署在web.xml文件中的DispatcherServlet的名称，而-servlet.xml是配置文件名的固定写法，如在WEB-INF下查找springmvc-servlet.xml文件。

6. 控制器方法的返回值类型

ModelAndView类型中可以添加Model数据，并指定视图；String类型的返回值可以跳转视图，但不能携带数据；而void类型主要在异步请求时使用，它只返回数据，而不会跳转视图。

7. @Controller注解在使用时可分为如下两步：

（1）在相应的类上标注@Controller注解。
（2）在Spring MVC的配置文件中添加相应的扫描配置信息。首先需要在配置文件中引入context名称空间的配置，然后使用context:component-scan元素指定需要扫描的类包。

8. SpringMVC框架下请求处理方法的参数类型：

基于SpringMVC框架下请求处理方法的参数类型主要有：HttpServletRequest、HttpServletResponse、HttpSession、Model、HttpMethod等；
基于SpringMVC框架下请求处理方法的返回类型主要有：ModelAndView、Map、String、void、HttpEntity<?>、View等。

9. SpringMVC中获取输入值的方式主要有：

在action的方法中写与请求参数同名的变量

在action的方法的参数中使用HttpServletRequest、HttpServletResponse、HttpSession、Model、HttpMethod等对象

在方法的参数中使用@RequestParam注解

界面上的输入信息是某个自定义对象的信息，在接收的时候直接封装为该自定义对象

把请求参数放到请求路径中，即采用RESTful风格。

10. SpringMVC中对用户的响应方式主要有：

返回ModelAndView对象，如new ModelAndView(“studentList”,model)，第一个参数表示视图，第二参数表示视图中需要的数据。

	@RequestMapping("/studentUpdateView.do")
	public ModelAndView updateView(String id){
		Student student = studentService.findById(id);
		Map<String,Object> model = new HashMap<String,Object>();
		model.put("student",student);
		return new ModelAndView("studentUpdate",model);
	}

控制层的方法返回值类型为String，在方法中返回表示输出界面的字符串，与ModelAndView中的第一个参数相同

@RequestMapping("studentAddView.do")
public String addView(){
return "studentAdd";
}

使用String表示要返回的视图，使用Model表示要返回的数据。在请求方法的参数中定义Model对象，在请求方法体中把数据存储到Model对象中响应给前端页面。

@RequestMapping("/studentList.do")
public String studentList(Model model){
List<Student> students = studentService.getStudents();
model.addAttribute("students",students);
return "studentList";
}

返回JSON数据。

11. @RequestParam注解

@RequestParam注解主要用于对请求中的参数进行定义，多用于在请求参数名与方法形参名不一致时的参数间接绑定。在使用时可以指定他的4个属性，具体如下：
（1）value：name属性的别名，这里指参数的名字，即入参的请求参数名字，如果只使用vaule属性，则可以省略value属性名。
（2）name：用于指定请求头绑定的名称。
（3）required ：用于指定参数是否必须，默认是true，表示请求中一定要有相应的参数。
（4）defaultValue：默认值，表示如果请求中没有同名参数时的默认值。

12. 在使用包装POJO类型数据绑定时

在使用包装POJO类型数据绑定时，前端请求的参数名编写必须符合以下两种情况：
（1）如果查询条件参数是包装类的直接基本属性，则参数名直接用对应的属性名；
（2）如果查询条件参数是包装类中POJO的子属性，则参数名必须为“对象.属性”，其中“对象”要和包装POJO中的对象属性名称一致，“属性”要和包装POJO中的对象子属性一致。

13. JSON数据交互时，主要使用的两个注解@RequestBody和@ResponseBody

JSON数据交互时，主要使用了两个注解@RequestBody和@ResponseBody。其中@RequestBody用于将请求体中的数据绑定到方法的形参中，在使用时标准在在方法的形参上。@ResponseBody用于直接返回return对象。Jackson用到的开源包的有 jackson-annoations-2.8.8.jar、 jackson-core-2.8.8.jar、jackson-databind-2.8.8.jar。

14. JSON对象的数组结构

JSON对象的数组结构以 “[” 开始，以 “]” 结束，对象结构以 “{” 开始，以 “}”结束，JSON对象数据结构的中间部分由键值对（key：value）以英文 “,” 分隔的值的列表组成。关键字（key）必须为String类型，值（value）可以是String、Number、Object、Array等数据类型。

15. RESTful

RESTful也称之为REST，是英文“Representational State Transfer”的简称。RESTful风格在HTTP请求中，使用put、delete、post和get方式分别对应添加、删除、修改和查询的操作。

16. @PathVariable(“id”)注解

@PathVariable(“id”)注解用于接收并绑定请求参数，它可以将URL请求中的变量映射到请求方法的形参上。
如果请求路径中的参数名方法形参名称一样，则@PathVariable后面的 “ (“id”) ” 可以省略。

17. Spring MVC的文件上传

Spring MVC的文件上传是通过MultipartResolver对象实现的。

文件上传表单需要满足的3个条件如下：
（1） form表单的method属性设置为post；
（2） form表单的enctype属性设置为multipart/form-data；
（3）提供的文件上传输入框。

四、拦截器

1. HandlerInterceptor接口中有3个方法：

（1） preHandler()方法：该方法会在控制器方法前执行，其返回值表示是否中断后续操作。当其返回值为true时，表示继续向下执行；当其返回值为false时，会中断后续的所有操作。
（2） postHandle()方法：该方法会在控制器方法调用之后，且解析视图之前执行。可以通过此方法对请求域中的模型和视图做出进一步的修改。
（3） afterCompletion()方法：该方法会在整个请求完成，即视图渲染结束之后执行。可以通过此方法实现一些资源清理、记录日志信息等工作。

2. 拦截器类定义

通常拦截器类可以通过两种方式来定义。
一种是通过实现HandlerInterceptor接口，或继承HandlerInterceptor接口的实现类（如HandlerInterceptorAdapter）来定义；
另一种是通过实现WebRequestInterceptor接口，或继承WebRequestInterceptor接口的实现类来定义。

3. 单个/多个拦截器工作

在执行时，程序首先会执行拦截器类中的preHandle()方法，如果该方法的返回值为true，则程序会继续向下执行处理器中的方法，否则将不再向下执行；
在业务处理器（即控制器Controller类）处理完请求后，会执行postHandle()方法，然后会通过DispatcherServlet向客户端返回响应；在DispatcherServlet处理完请求后，才会执行afterCompletion()方法。
当有多个拦截器同时工作时，它们的preHandle()方法会按照配置文件中拦截器的配置顺序执行，而它们的postHandle()方法和afterCompletion()方法则会按照配置顺序的反序执行。

4. 拦截器的配置和执行流程：

在这里插入图片描述

单个拦截器执行流程：

在这里插入图片描述

多个拦截器执行流程：

在这里插入图片描述

5. 定时器的作用：

定时器的作用：在特定的时候去执行一些任务或者按照特定的时间间隔去执行一些任务，
例如定时读取邮件信息。

使用@Scheduled注解，通过cron设置按照特定的规律触发定时器
@Scheduled(cron=“*/10 * * * * ? ”)，10秒

按照固定的频率执行定时器
@Scheduled(fixedRate = 1000*2)，两秒执行一次

五、Mybatis

1. Hibernate和MyBatis

Hibernate和MyBatis。这两个框架的主要区别如下：

（1）Hibernate：

Hibernate：是一个全表映射的框架。通常开发者只需定义好持久化对象到数据库表的映射关系，就可以通过Hibernate提供的方法完成持久层操作。开发者并不需要熟练的掌握SQL语句的编写，Hibernate会根据制定的存储逻辑，自动的生成对应的SQL，并调用JDBC接口来执行，所以其开发效率会高于MyBatis。
然而Hibernate自身也存在着一些缺点，例如它在多表关联时，对SQL查询的支持较差；更新数据时，需要发送所有字段；不支持存储过程；不能通过优化SQL来优化性能等。这些问题导致其只适合在场景不太复杂且对性能要求不高的项目中使用。

（2）MyBatis：

MyBatis：是一个半自动映射的框架。这里所谓的“半自动”是相对于Hibernate全表映射而言的，MyBatis需要手动匹配提供POJO、SQL和映射关系，而Hibernate只需提供POJO和映射关系即可。
与Hibernate相比，虽然使用MyBatis手动编写SQL要比使用Hibernate的工作量大，但MyBatis可以配置动态SQL并优化SQL，可以通过配置决定SQL的映射规则，它还支持存储过程等。对于一些复杂的和需要优化性能的项目来说，显然使用MyBatis更加合适。

MyBatis框架是当前主流的Java持久层（数据访问层DAO）框架之一，它与Hibernate一样，也是一种ORM（Object/Relation Mapping，即对象关系映射）框架。所谓的ORM就是一种为了解决面向对象与关系型数据库中数据类型不匹配的技术，它通过描述Java对象与数据库表之间的映射关系，自动将Java应用程序中的对象持久化到关系型数据库的表中。

2. MyBatis核心组件：

SqlSessionFactoryBuilder（构造器）: 根据XML配置（推荐方式）或者代码来生成SqlSessionFactory（工厂接口）对象, 创建完成后该对象就不需要了，所以只需要使用一次，后面无需保存。

SqlSessionFactory：依靠工厂来创建SqlSession（会话）对象；该对象是线程安全的，所以整个应用只需要保存一个。

SqlSession：类似于一个JDBC的Connection对象。是一个既可以发送SQL去执行并返回结果，也可以获取Mapper的接口。

SQL Mapper：是MyBatis新设计的组件，是由一个Java接口和XML文件（或注解）构成的，需要给出对应的SQL和映射规则。负责发送SQL去执行，并返回结果。通过namespace.id调用Mapper中定义的SQL。

3. MyBatis框架的工作执行流程如下：

（1）读取MyBatis配置文件mybatis-config.xml。
（2）加载映射文件Mapper.xml。
（3）构建会话工厂。
（4）创建SqlSession对象。
（5）使用Executor接口来操作数据库。
（6）使用MappedStatement类型的参数对映射信息进行封装。
（7）输入参数映射。
（8）输出结果映射。

4. `<sql>`元素

<sql>元素的作用就是定义可重用的SQL代码片段。使用时，先通过<sql>元素定义重用的代码片段，然后在需要使用的地方使用<include>元素的refid属性引用了自定义的代码片段。

5. MyBatis核心对象SqlSessionFactory的获取方式：

SqlSessionFactory对象的实例可以通过SqlSessionFactoryBuilder对象来构建，而SqlSessionFactoryBuilder则可以通过XML配置文件或一个预先定义好的Configuration实例构建出SqlSessionFactory的实例，通过XML配置文件构建出的SqlSessionFactory实例，其实现代码如下：

// 读取配置文件
InputStream inputStream = Resources.getResourceAsStream("配置文件位置");
// 根据配置文件构建SqlSessionFactory
SqlSessionFactory sqlSessionFactory = 
new SqlSessionFactoryBuilder().build(inputStream);

MyBatis使用过程：

使用SqlSessionFactoryBuilder创建SqlSessionFactory对象;

然后通过SqlSessionFactory创建SqlSession对象;

通过SqlSession对象完成基本操作（执行SQL）。

关闭SqlSession。

6. `<mapper>`元素

在映射文件中，<mapper>元素是映射文件的根元素，其他元素都是它的子元素。这些子元素及其作用如下所示：
<select>：用于映射查询语句，可自定义参数，返回结果集等。
<insert>：用于映射插入语句，执行后返回一个整数，代表插入的条数。
<update>：用于映射更新语句，执行后返回一个整数，代表更新的条数。
<delete>：用于映射删除语句，执行后返回一个整数，代表删除的条数。
<sql>：用于定义一部分SQL，然后可被其他语句引用此SQL。
<cache>：用于给定命名空间的缓存配置。
<cache-ref>：用于其他命名空间缓存配置的引用。
<resultMap>：用于描述如何从数据库结果集中来加载对象。

当数据表中的列和需要返回的对象的属性不完全一致， MyBatis是不会自动赋值的。此时，就可以使用<resultMap>元素进行处理。<resultMap>元素的子元素用于表示哪个列是主键，而<result>元素用于表示POJO和数据表中普通列的映射关系。

<resultMap id="custResultMap" type="Customer">
       <id property="id" column="id" />
       <result property="custId" column="cust_id"/>
       <result property="name" column="name"/>
</resultMap>

7. mybatis中映射文件include标签应用

MyBaits映射文件中使用<include>元素的 refid 属性可以引用自定义的代码片段，其属性值为自定义代码片段的id。

<sql id="custColumns"> 
	cust_id custId,name,age 
</sql>    
<select id="sqlCustList" resultType="Customer">
	select
		<include refid="custColumns"/>   
		from customer c
</select>

8. MyBatis映射文件中`<mapper>`元素

MyBatis映射文件中<mapper>元素是配置文件的根元素，它包含一个namespace属性，该属性为这个<mapper>指定了唯一的命名空间。在Mybatis映射文件中，每个操作都有一个id属性表示操作的唯一标识。

<mapper namespace="customer">
     <select id="customerList" resultType="Customer">
         select * from customer
     </select>
</mapper>

9. MyBatis映射文件中`<insert>`元素

MyBatis映射文件中<insert>元素用于映射插入语句，在执行完元素中定义的SQL语句后，与<update>和<delete>元素在执行完之后一样，也会返回一个表示影响记录条数的整数。<insert>元素的属性与<select>元素的属性不同，可以使用keyProperty属性指定哪个是主键字段，使用useGeneratedKeys属性定义主键是否使用数据库内置策略生成，从而实现对于表中自增编号主键列的主键回填和自定义功能。

10. 根据MyBatis的映射文件编写Mapper接口过程中涉及的关键问题如下：

通常一个映射文件对应一个Mapper接口，映射文件中的namespace与接口的全限定名一致。

映射文件中每个操作id对应Mapper接口的一个方法，方法名与映射文件中操作的id相同，参数类型和返回值类型与操作中的parameterType和resultType相同

SQL调用的时候通过接口调用，而不用再指出操作的id

11. MyBatis配置XML文件结构如下

mybatis-config.xml作为MyBatis的全局配置文件，配置了MyBatis的运行环境等信息。
MyBatis配置XML文件结构如下：

 <configuration><!-- 配置-->
     <properties/><!-- 属性-->
     <settings/><!--设置-->
     <typeAliases/><!-- 类型命名-->
     <typeHandlers/> <!--类型处理器-->
     <objectFactory/>  <!– 对象工厂 -->
     <plugings/>  <!--插件 -->
     <environments> <!--配置环境-->
         <environment> <!--环境变量-->
             <transactionManager/><!--事务管理器-->
             <dataSource/> <!--数据源-->
           </environment>
     </environments>
     <databaseIdProvider/><!--数据库厂商标识-->
     <mappers/> <!--映射器-->
</configuration>

这些层次是不能够颠倒顺序的，如果颠倒顺序，MyBatis在解析XML文件的时候就会出现异常。例如：

<configuration>  
     <typeAliases>
         <typeAlias type="entity.Customer" alias="Customer" />
         <typeAlias type="entity.Course" alias="Course" />
         <typeAlias type="entity.QuickManual" alias="QuickManual" />
     </typeAliases>
     <environments default="development">
         <environment id="development">
             <transactionManager type="JDBC"></transactionManager>
             <dataSource type="POOLED">
                 <property name="driver" value="com.mysql.jdbc.Driver" />
                 <!-- ?useUnicode=true&amp;characterEncoding=utf8为了支持中文数据的写入 -->
                 <property name="url"
                     value="jdbc:mysql://localhost:3306/test?useUnicode=true&amp;characterEncoding=utf8" />
                 <property name="username" value="root" />
                 <property name="password" value="root" />
             </dataSource>
         </environment>
     </environments>
     <mappers>
         <mapper resource="mapper/CustomerMapper.xml" />
         <mapper resource="mapper/CourseMapper.xml" />
         <mapper resource="mapper/QuickManualMapper.xml" />
     </mappers>
</configuration>

六、SSM框架整合

1. MyBatis与Spring整合所需JAR包主要包括

MyBatis与Spring整合所需JAR包主要包括：Spring框架所需的JAR包、 MyBatis框架所需的JAR包、MyBatis与Spring整合的中间JAR、数据库驱动JAR包，以及数据源所需的JAR包。

2. MapperFactoryBean与MapperScannerConfigurer

MapperFactoryBean是MyBatis-Spring团队提供的一个用于根据Mapper接口生成Mapper对象的类，通过MapperFactoryBean可以配置接口文件以及注入SqlSessionfactory，从而完成一个Bean的实例化。

MapperScannerConfigurer是MyBatis-Spring团队提供的一种用于以自动扫描形式来配置MyBatis中映射器的类，可以通过配置包路径来自动扫描包接口生成映射器，这使得开发人员可以在编写很少代码的情况下，完成对映射器的配置，从而提高开发效率。

3. 三大框架整合

由于Spring MVC是Spring框架中的一个模块，所以Spring MVC与Spring之间不存在整合的问题，只要引入相应JAR包就可以直接使用。因此SSM框架的整合就只涉及到了Spring与MyBatis的整合，以及Spring MVC与MyBatis的整合。Spring与MyBatis框架的整合时，通过Spring实例化Bean，然后调用实例对象中的查询方法来执行MyBatis映射文件中的SQL语句的，如果能够正确查询出数据库中的数据，那么就可以认为Spring与MyBatis框架整合成功。加入Spring MVC后，如果可以通过前台页面来执行查询方法，并且查询出的数据能够在页面中正确显示，那么就可以认为三大框架整合成功。

4. SSM框架整合时，Spring配置文件中配置信息主要包括：

（1）读取数据库常量配置文件db.properties的配置信息；
（2）数据源的配置信息；
（3）事务管理器的配置信息；
（4）开启事务注解的配置；
（5）MyBatis工厂SqlSessionFactory的配置信息；
（6）mapper文件扫描器的配置；
（7）扫描Service层的配置。

5. 配置MyBatis中的映射器——采用MapperScannerConfigurer类

在MyBatis+Spring的项目中，事务是由Spring来管理的。MyBatis-Spring团队提供了一种自动扫描的形式来配置MyBatis中的映射器——采用MapperScannerConfigurer类。

6. 在进行Spring与MyBatis整合时

a) Spring框架所需要准备的JAR包共10个，其中包括：4个核心模块JAR，AOP开发使用的JAR，JDBC和事务的JAR。

b) Dao层开发可以使用传统的DAO方式的开发整合，以及Mapper接口方式的开发整合。可以使用mybatis-spring包中所提供的SqlSessionTemplate类或SqlSessionDaoSupport类来实现向DAO实现类中注入SqlSessionFactory。

7. SSM框架整合

SSM框架整合主要是Spring与Mybatis的整合，以及SpringMVC与Mybatis的整合。为了避免Spring配置文件中的信息过于臃肿，通常会将Spring配置文件中的信息按照业务功能的不同分散在多个配置文件中。在整合项目中，db.properties文件主要用于数据库常量的配置。

Spring与MyBatis框架的整合时，可以通过Spring实例化Bean，然后调用实例对象中的查询方法来执行MyBatis映射文件中的SQL语句，如果能够正确查询出数据库中的数据，就可以认为Spring与MyBatis框架整合成功。
SSM框架整合配置文件spring-servlet.xml示例：

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:mvc="http://www.springframework.org/schema/mvc" 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-3.0.xsd
        http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/mvc
	    http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
		">

	<!--组件扫描-->
	<context:component-scan base-package="action" />
	<context:component-scan base-package="service" />
	<context:component-scan base-package="dao" />
	<!--启动注解-->
    <mvc:annotation-driven/>
    <!-- 配置视图解析器 -->
	<bean
	class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/views/" />
		<property name="suffix" value=".jsp" />
	</bean>
		   
	<!-- 配置mybatis：配置SqlSessionFactory -->
	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">

		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost:3306/test" />
		<property name="username" value="root" />
		<property name="password" value="root" />
	</bean>
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="configLocation" value="classpath:mybatis_config.xml"></property>
	</bean>
	
		<!-- Spring和MyBatis整合:配置扫描Dao接口的包，动态实现Dao接口，注入到Spring容器中 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 给出需要扫描的Dao接口包 ，set注入-->
        <property name="basePackage" value="dao" />
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
    </bean>
</beans>

七、SpringAOP和事务控制

1. AOP(Aspect-Oriented Programming,面向切面编程)：

是Spring用到的核心技术之一，是对传统 OOP(Object-Oriented Programming,面向对象编程)的补充。

AOP在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等。

AOP的主要编程对象是切面(aspect)，采用AOP，可以对分散在各处且与对象核心功能无关的一些功能行为代码（横切代码）进行封装，使其成为一个可重用的模块，这个模块被命名为“切面”（Aspect），切面将那些与业务无关，却被业务模块共同调用的逻辑提取并封装起来，减少了系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。

2. AOP框架：Spring AOP和AspectJ。

目前流行的AOP框架有两个：Spring AOP和AspectJ

Spring AOP代理可以是JDK动态代理，也可是CGLIB代理。Spring默认使用JDK动态代理，在需要代理类而不是代理接口的时候，Spring会自动切换为使用CGLIB代理，不过现在的项目都是面向接口编程，所以JDK动态代理相对来说用的还是多一些。

新版本的Spring框架，建议使用AspectJ来开发AOP。使用AspectJ实现AOP有两种方式：一种是基于XML的声明式AspectJ，另一种是基于注解的声明式AspectJ。

3. AspectJ框架中注解

AspectJ框架中注解@Pointcut用于定义切入点表达式，在使用时还需定义一个包含名字和任意参数的方法签名来表示切入点名称。

4. Spring的配置文件中的`<beans>`元素

在Spring的配置文件中的<beans>元素下可以包含多个<aop:config>元素，一个<aop:config>元素中又可以包含属性和子元素，其子元素包括<aop:pointcut>、<aop:advisor>和<aop:aspect>。
配置切面使用的是<aop:aspect>元素，<aop:aspect>子元素的pointcut-ref属性用于指定一个已经存在的切入点名称。