Spring

一、Spring简介

1.1 Spring介绍

​ Spring框架是一个非常活跃的开源框架, 基于IOC和AOP来构架多层JavaEE系统，以帮助分离项目组件之间的依赖关系,它的主要目地是简化企业开发.

1.2 Spring解决的问题

• 方便解耦，简化开发：Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
• AOP 编程的支持：Spring 提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能
• 声明式事务的支持：只需要通过配置就可以完成对事务的管理，而无需手动编程
• 方便程序的测试：Spring 对 Junit4 支持，可以通过注解方便的测试 Spring 程序
• 方便集成各种优秀框架：spring是一个一站式的开源框架。Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持
• 降低 JavaEE API 的使用难度：Spring对 JavaEE 开发中非常难用的API（JDBC、JavaMail、远程调用等），都提供了封装，使这些 API 应用难度大大降低

1.3 Spring的组成

Spring框架包含的功能大约由20个模块组成。这些模块按组可分为核心容器、数据访问/集成，Web，AOP(面向切面编程)、设备、消息和测试

ORM:(Object relation mapping) 对象关系映射 操作数据库的。

Object ：java对象 User Product实体类

relation：关系型数据库 数据库表

mapping：映射【xml配置文件】 通过映射把实体类和数据库表进行关联，达到操作实体类能够操作数据库表的目的。User类和user表进行关联。

hibernate就是一个标准的orm框架。

core - 核心模块

• spring-core：依赖注入IoC与DI的最基本实现
• spring-beans：Bean工厂与bean的装配
• spring-context：spring的context上下文即IoC容器
• spring-context-support
• spring-expression：spring表达式语言

详细说明

（1）spring-core

这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类

（2）spring-beans

这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring- beans.jar文件就可以了

（3）spring-context

Spring核心提供了大量扩展，这样使得由 Core 和 Beans 提供的基础功能增强：这意味着Spring 工程能以框架模式访问对象。Context 模块继承了Beans 模块的特性并增加了对国际化（例如资源绑定）、事件传播、资源加载和context 透明化（例如 Servlet container）。同时，也支持JAVA EE 特性，例如 EJB、 JMX 和 基本的远程访问。Context 模块的关键是 ApplicationContext 接口。spring-context-support 则提供了对第三方库集成到 Spring-context 的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。

（4）spring-expression

为在运行时查询和操作对象图提供了强大的表达式语言。它是JSP2.1规范中定义的统一表达式语言的扩展，支持 set 和 get 属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从Spring IoC容器检索对象，还支持列表的投影、选择以及聚合等。

数据访问与集成层包含 JDBC、ORM、OXM、JMS和事务模块。

（1）spring-jdbc

提供了 JDBC抽象层，它消除了冗长的 JDBC 编码和对数据库供应商特定错误代码的解析。

（2）spring-tx

支持编程式事务和声明式事务，可用于实现了特定接口的类和所有的 POJO 对象。编程式事务需要自己写beginTransaction()、commit()、rollback()等事务管理方法，声明式事务是通过注解或配置由 spring 自动处理，编程式事务粒度更细。

（3）spring-orm

提供了对流行的对象关系映射 API的集成，包括 JPA、JDO 和 Hibernate 等。通过此模块可以让这些 ORM 框架和 spring 的其它功能整合，比如前面提及的事务管理。

（4）spring-oxm

模块提供了对 OXM 实现的支持，比如JAXB、Castor、XML Beans、JiBX、XStream等。

（5）spring-jms

模块包含生产（produce）和消费（consume）消息的功能。从Spring 4.1开始，集成了 spring-messaging 模块

Spring 处理Web层jar

Web 层包括 spring-web、spring-webmvc、spring-websocket、spring-webmvc-portlet 等模块。

详细说明

（1）spring-web

提供面向 web 的基本功能和面向 web 的应用上下文，比如 multipart 文件上传功能、使用 Servlet 监听器初始化 IoC 容器等。它还包括 HTTP 客户端以及 Spring 远程调用中与 web 相关的部分

（2）spring-webmvc

为 web 应用提供了模型视图控制（MVC）和 REST Web 服务的实现。Spring 的 MVC 框架可以使领域模型代码和 web 表单完全地分离，且可以与 Spring 框架的其它所有功能进行集成

（3）spring-webmvc-portlet

（即Web-Portlet模块）提供了用于 Portlet 环境的 MVC 实现，并反映了 pring-webmvc 模块的功能

Spring AOP涉及jar

（1）spring-aop

提供了面向切面编程（AOP）的实现，可以定义诸如方法拦截器和切入点等，从而使实现功能的代码彻底的解耦。使用源码级的元数据。

（2）spring-aspects

提供了对 AspectJ 的集成

Instrumentation 模块涉及jar

（1）spring-instrument

模块提供了对检测类的支持和用于特定的应用服务器的类加载器的实现。

（2）spring-instrument-tomcat

模块包含了用于 Tomcat 的Spring 检测代理。

Messaging消息处理 涉及jar

spring-messaging 模块

从 Spring 4 开始集成，从一些 Spring 集成项目的关键抽象中提取出来的。这些项目包括 Message、MessageChannel、MessageHandler 和其它服务于消息处理的项目。这个模块也包含一系列的注解用于映射消息到方法

Test模块涉及jar

spring-test 模块

通过 JUnit 和 TestNG 组件支持单元测试和集成测试。它提供了一致性地加载和缓存 Spring 上下文，也提供了用于单独测试代码的模拟对象（mock object）

二、IOC:控制反转

​ (Inverse of Control) 就是指把创建对象的权利反转给spring容器。

1. 引入spring-context和spring-context-support两个jar依赖

2. 创建User类,Spring的配置文件

   public class User {
       private  Integer uid;
       private  String name;
       private String password;
   
       public User() {
       }
       @Override
       public String toString() {......}
       getter() setter()
   }
   

   <?xml version="1.0" encoding="UTF-8"?>
   <beans>
    <!--
           id=是唯一的   通过id值可以找到该类的实例
           class：类的全路径
           默认使用无参数构造。
       -->
       <bean id="user" class="ioc.User"/>
   </beans>
   

3. 测试

   public static void main(String[] args) {
   //ClassPathXmlApplicationContext使用该类去加载配置文件
           ApplicationContext context = new ClassPathXmlApplicationContext("aplicationContext.xml");
           //获得springbean工厂管理  user类
          User user=context.getBean("user", User.class);
          user.setName("jack");
          System.out.println(user);
       }
   

三. 对象创建的细节

3.1 bean标签和属性讲解

bean标签:是根标签beans内部必须包含的标签,它是用于声明具体的类的对象!

bean标签对应的属性

   <?xml version="1.0" encoding="UTF-8"?>
   <beans ......>
       <!--
	   name 可以重复,可以使用特殊字符
       id是唯一的 通过id值可以找到该类的实例 不能使用特殊字符 作用和name几乎相同
       class:类的全路径
       默认使用无参构造
       scope:默认是singleton单例的 如果想使用多例的:scope="prototype"
       lazy-init:false 默认false 只对单例有效,设置单例时使用 加载配置文件就会创建该实例
	   lazy-init:true 延迟初始化,在用到对象的时候才会创建对象
       init-method="init"配置初始化方法
       destroy-method="des"配置销毁方法
       -->
       <bean name="user" id="user" class="cgp.model.User" scope="singleton" lazy-init="true" init-method="init" destroy-method="des"/>
   
       <!--
       静态工厂模式
       class:工厂的类
       factory-method:工厂的静态方法
       -->
       <bean id="user2" class="cgp.model.UserFactory" factory-method="getUser"/>
   
       <!--
       非静态工厂模式:
       class:工厂的类
       factory-method:工厂的静态方法
       factory-bean:工厂的实例的id
       -->
       <bean id="fac" class="cgp.model.UserFactory"/>
       <bean id="user3" factory-bean="fac" factory-method="getUser2"/>
   </beans>

四、DI依赖注入

​ Dependency Injection，说的是创建对象实例时，同时为这个对象注入它所依赖的属性。相当于把每个bean与bean之间的关系交给容器管理。而这个容器就是spring。

案例步骤:

1. .准备spring的环境

2. UserController

   UserService UserServiceImpl

   UserDao UserDaoImpl

3. 编写配置文件

   <?xml version="1.0" encoding="UTF-8"?>
   <beans ...>
       <!--把控制器交给spring-->
       <bean id="userController" class="di.UserController">
       <!--
           1.一定要在UserController里面注入的属性提供getter和setter方法，默认使用setter方法注入。
           name:setUserService方法名  去掉set首字母变小写
           ref=引用其他bean的id
        -->
        <!--注入service-->
           <property name="userService" ref="userService"/>
       </bean>
   
       <!--把控制器交给spring-->
       <bean id="userService" class="di.UserServiceImpl">
           <!--注入dao-->
           <property name="userDao" ref="userDao"/>
       </bean>
   
       <!--把控制器交给spring-->
       <bean id="userDao" class="di.UserDaoImpl"/>
   </beans>
   

4. 测试代码

   public static void main(String[] args) {
      ApplicationContext context = new ClassPathXmlApplicationContext("di/di.xml");
      //获得springbean工厂管理 user 类
      UserController uc= context.getBean("userController", UserController.class);
      uc.add();
   }
   

4.1 set方法注入

4.1.1 基本类型值注入使用value

<bean name="person" class="cgp.model.Person">
    <!-- value值为基本类型 -->
    <property name="name" value="jack"/>
    <property name="age" value="18"/>
</bean>

测试代码

public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person person = context.getBean("person", Person.class);
        System.out.println("person = " + person);//输出toString
}

4.1.2 引用类型值注入ref
利用ref属性给 person的car属性赋值

<bean name="person" class="cgp.model.Person">
    <property name="name" value="jack"/>
    <property name="age" value="18"/>
    <property name="car" ref="car"/>
</bean>
<bean name="car" class="cgp.model.Car">
    <property name="name" value="大众"/>
    <property name="color" value="白色"/>
</bean>

测试代码同上

4.2 构造函数注入

4.2.1 单个有参构造方法注入

//在Person中创建有参构造函数
public Person(String name, Car car) {
    this.name = name;
    this.car = car;
    System.out.println("Person的有参构造");
}

配置xml

<bean name="person" class="cgp.model.Person">
    <constructor-arg name="name" value="chen"/>
    <constructor-arg name="car" ref="car"/>
</bean>
<bean name="car" class="cgp.model.Car">
    <property name="name" value="大众"/>
    <property name="color" value="白色"/>
</bean>

测试代码同上,会调用Person的有参构造

4.2.2 index属性:按参数索引注入
参数名一致,但位置不一致时,使用index

public Person(String name, Car car) {
    this.name = name;
    this.car = car;
    System.out.println("Person(String name, Car car)");
}
//这两个构造函数的参数名相同,位置不同
public Person(Car car,String name){
    this.name = name;
    this.car = car;
    System.out.println("Person(Car car,String name)");
}

配置xml：使用index确定调用哪个构造函数

<bean name="person" class="cgp.model.Person">
    <constructor-arg name="name" value="chen" index="1"/>
    <constructor-arg name="car" ref="car" index="0"/>
</bean>
<bean name="car" class="cgp.model.Car">
    <property name="name" value="大众"/>
    <property name="color" value="白色"/>
</bean>

测试代码同上,会调用Person的第二个有参构造

4.2.3 type属性:按参数类型注入
参数名和位置一致，但类型不一致时，使用type

public Person(Car car,String name){
    this.name = name;
    this.car = car;
    System.out.println("Person(Car car,String name)");
}

public Person(Car car,Integer name){
    this.name = name+"";
    this.car = car;
    System.out.println("Person(Car car,Integer name)");
}

配置：使用type指定参数的类型

<bean name="person" class="cgp.model.Person">
    <constructor-arg name="name" value="123" type="java.lang.Integer"/>
    <constructor-arg name="car" ref="car"/>
</bean>
<bean name="car" class="cgp.model.Car">
    <property name="name" value="大众"/>
    <property name="color" value="白色"/>
</bean>

测试代码同上,会调用Person的Integer的有参构造

4.3 p名称空间注入

导入p名称空间:
使用p:属性名 完成注入,走set方法

• 基本类型值: p:属性名=“值”

• 引入类型值: P:属性名-ref=“bean名称”

配置

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--1.第一步配置文件中 添加命名空间p
    xmlns:p="http://www.springframework.org/schema/p"
    -->
    <!--使用p命名空间进行赋值-->
    <bean name="person" class="cgp.model.Person" p:name="chen" p:age="18" p:car-ref="car"/>
    <bean name="car" class="cgp.model.Car">
        <property name="name" value="大众"/>
        <property name="color" value="白色"/>
    </bean>
</beans>

测试代码同上,会调用Person的无参构造

4.4 spel注入

spring Expression Language：spring表达式语言

value="#{}"都是使用value:
{}里面写整形 #{100+100*2}
{}写字符串：#{‘Manaphy’}
方法调用：#{‘中华人民共和国’.substring(1,2)}
调用静态方法：#{T(类).方法}
调用对象的属性：#{user.name}

配置方式:

<bean name="car" class="cgp.model.Car">
    <property name="name" value="大众"/>
    <property name="color" value="白色"/>
</bean>
<!--利用spel引入car的属性-->
<bean name="person" class="cgp.model.Person" p:car-ref="car">
    <property name="name" value="#{car.name}"/>
    <property name="age" value="#{person.age}"/>
</bean>
<!--注入日期类型：默认支持 yyyy/MM/dd的日期格式的字符串转Date-->
<bean id="user" class="cgp.model.User">
    <property name="date" value="#{'2012/12/12'}"/>
    <property name="date1" value="#{new java.util.Date()}"/>
    <!--spel支持运算-->
    <property name="uid" value="#{100+12*2}"/>
    <!--spel支持访问其他bean属性-->
    <property name="name" value="#{car.name}"/>
    <!--spel调用静态方法 T(类名).方法()-->
    <property name="password" value="#{T(java.util.UUID).randomUUID().toString()}"/>
</bean>

4.5 复杂类型注入

public class TestCollection {
    private Object[] arrs;
    private List<Object> list;
    private Map<String,Object> map;
    private Properties properties;

    public TestCollection() {
    }

    getter()  setter()

    @Override
    public String toString() {...}
}

配置:

<bean name="car" class="cgp.model.Car">
    <property name="name" value="大众"/>
    <property name="color" value="白色"/>
</bean>
<bean name="testColl" class="cgp.model.TestCollection">
    <!--数组变量注入-->
    <property name="arrs">
        <list>
            <value>数组1</value>
            <!--引入其他类型-->
            <ref bean="car"/>
        </list>
    </property>
    <!--集合变量赋值-->
    <property name="list">
        <list>
            <value>集合1</value>
            <!--集合变量内部包含集合-->
            <list>
                <value>集合中的集合1</value>
                <value>集合中的集合2</value>
                <value>集合中的集合3</value>
            </list>
            <ref bean="car"/>
        </list>
    </property>
    <!--map赋值-->
    <property name="map">
        <map>
            <entry key="car" value-ref="car"/>
            <entry key="name" value="保时捷"/>
            <entry key="age" value="11"/>
        </map>
    </property>
    <!--properties赋值-->
    <property name="properties">
        <props>
            <prop key="name">age</prop>
            <prop key="age">111</prop>
        </props>
    </property>
</bean>

测试:

public class TestColl {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        TestCollection testColl = context.getBean("testColl", TestCollection.class);
        System.out.println("testColl = " + testColl);
    }
}
//testColl = TestCollection{arrs=[数组1, Car{name='大众', color='白色'}], list=[集合1, [集合中的集合1, 集合中的集合2, 集合中的集合3], Car{name='大众', color='白色'}], map={car=Car{name='大众', color='白色'}, name=保时捷, age=11}, properties={age=111, name=age}}

4.6 在spring的配置文件中加载

db.properties:

jdbc.username=root
jdbc.password=1111
jdbc.url=jdbc:mysql://localhost:3306/shop?serverTimezone=GMT%2B8
jdbc.driverclass=com.mysql.cj.jdbc.Driver

<context:property-placeholder location="classpath:conf/*.properties"/>

然后通过以下方式可以使用里面的值：

<property name="driverClassName" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="url" value="${jdbc.url}"/>

五、使用注解

使用注解的方式完成IOC和DI.
使用一些spring给我们提供的注解来代替我们原来写的xml方式.我们真正开发的时候基本都是注解开发.
注解：比如：@Test , @Controller

导入相关的jar包

引入Context的约束,并配置注解扫描

<?xml version="1.0" encoding="UTF-8"?>
<!--较之前多了 xmlns:context -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans 						  http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context.xsd"> 
	<context:component-scan base-package="cgp.spring.bean">
</beans>

注解的使用

@Component("person")// <bean name="person" class="cgp.spring.bean.Person" />
public class Person {
    private String name;
    private Integer age;
    private Car car;

    public  Person(){
        System.out.println("无参数构造方法!");
    }
  //getter,setter,toString
} 

5.1 类头部可用的注解

这几个注解的功能和@Component 一样。

@Service("person") 		// service层
@Controller("person") 	// controller层
@Repository("person")	// dao层

5.2 类头部可用的注解

指定对象作用域

@Scope(scopeName="singleton") 单例 scopeName也可以换成value
@Scope(scopeName="prototype") 多例

5.3 注入属性value值

1.设置成员变量上:通过反射给变量赋值

@Value("name值")
private String name;

@Value(“name值”) 等同于 @Value(value=“name值”)

2.加在set方法上:通过set方法赋值

@Value("tom")
public void setName(String name){
    this.name = name;
}  

5.4 自动装配

1. @Autowired

使用 @Autowired 自动装配对象类型的属性: 下面的Person中的Car使用了自动装配

//将Car定义成接口
@Component
public interface Car {
     void log();
}

//Baoma实现Car
@Component
public class Baoma implements Car {
    public void log() {
        System.out.println("宝马");
    }
}

//XianDai实现Car
@Component
public class XianDai implements Car {

    public void log() {
        System.out.println("现代");
    }
}

装配类:

@Scope(scopeName = "prototype")
@Component("person")
public class Person {
    @Value("name值")
    private String name;
    private Integer age;
    @Autowired      
    private Car car;  //自动装配 可以选择Car,如果Car是接口,找Car的实现类!

注意: 以上操作会出现一个问题,如果Car是接口,且Car只有一个实现类,那么@Autowired会自动将实现类装配给Person的car变量上,但是如果Car是接口,并且有两个以上实现类,那么自动装配就会报错,无法选择由哪个实现类赋值.所以需要配合另一个注释@Qualifier(“bean name”), 这个属性可以将@Autowired按类型赋值改成按bean名字赋值.

5.5 @Qualifier

• 如果匹配多个类型一致的对象，将无法选择具体注入哪一个对象
• 使用@Qualifier()注解告诉spring容器自动装配哪个名称的对象。

@Scope(scopeName = "prototype")
@Component("person")
public class Person {
    @Value("name值")
    private String name;
    private Integer age;
    @Autowired  
    @Qualifier("baoma")   //指定实现类
    private Car car;  //自动装配 可以选择Car,如果Car是接口,找Car的实现类!

5.6 @Resource

@Resource 是java的注释,但是Spring框架支持,@Resource指定注入哪个名称的对象

@Resource(“name”) == @Autowired + @Qualifier(“name”)

@Resource(name="baoma") 
private Car car;

5.7 初始化和销毁方法

初始化和销毁方法等同于配置文件添加的init-method和destroy-method功能,

例:Person类中init方法和destroy方法添加如下注解:

 @PostConstruct
 public  void init(){
   System.out.println("初始化方法");
 }

 @PreDestroy
 public void destroy(){
   System.out.println("销毁方法");
 }

六、AOP面向切面编程

6.1 什么是AOP

1、在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2、AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码

3、 经典应用：事务管理、性能监视、安全检查、缓存 、日志等

4、 Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码对程序进行增强（不修改源码的情况下）

5、 AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入

6.2 AOP的底层实现

Srping框架的AOP技术底层也是采用的代理技术，代理的方式提供了两种

1. 基于JDK的动态代理

必须是面向接口的，只有实现了具体接口的类才能生成代理对象

2. 基于CGLIB动态代理

   对于没有实现了接口的类，也可以产生代理，产生这个类的子类的方式

Spring的传统AOP中根据类是否实现接口，来采用不同的代理方式

1. 如果实现类接口，使用JDK动态代理完成AOP
2. 如果没有实现接口，采用CGLIB动态代理完成AOP

6.3 动态代理

6.3.1 手动实现

public interface Worker {
    void workInDay(double money);
    void workInNight(double money);
}

public class XJJ implements Worker{

    @Override
    public void workInDay(double money) {
        System.out.println("上白班-->"+money);
    }

    @Override
    public void workInNight(double money) {
        System.out.println("上夜班-->"+money);
    }
}

//手动实现
public class XJJProxy implements Worker{
    private XJJ xjj;

    public XJJProxy() {
        this.xjj=new XJJ();
    }

    @Override
    public void workInDay(double money) {
        System.out.println("开启白班事物");
        xjj.workInDay(money);
        System.out.println("提交白班事物");
    }

    @Override
    public void workInNight(double money) {
        System.out.println("开启夜班事物");
        xjj.workInNight(money);
        System.out.println("提交夜班事物");
    }
}

//测试
public class DemoXJJ {
    public static void main(String[] args) {
        XJJProxy xjjProxy=new XJJProxy();
        xjjProxy.workInDay(1000);
        xjjProxy.workInNight(1500);
    }
}

6.3.2 JDK动态代理

public class DemoTest {
    //jdk的代理 需要接口实现
    public static void main(String[] args) {
        /**
         * 第一个参数:是类加载器
         * 第二个参数:目标类的父接口数组
         * 第三个参数:回调函数 当执行目标类的任意方法 都会走该方法
         */
        Worker proxyInstance = (Worker)Proxy.newProxyInstance(XJJ.class.getClassLoader(), XJJ.class.getInterfaces(), new InvocationHandler() {
            /**
             *
             * @param proxy 生成的代理类对象  一般不使用该对象
             * @param method 目标类正在执行的方法对象
             * @param args 目标类正在执行的方法的参数
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method.getName() + "--->方法执行之前 记录日志 开启事物");
                Object invoke = method.invoke(XJJ.class.newInstance(), (double) args[0] / 2);
                System.out.println("--->方法执行之后 记录日志 提交事物");
                return invoke;
            }
        });
        proxyInstance.workInDay(1000);
        proxyInstance.workInNight(1500);
    }
}

6.3.3 CGLIB字节码增强

public class DemoCglib {
    //cglib动态代理  基于子类
    public static void main(String[] args) {
        //1.获得代理类的核心类Enhancer对象
        Enhancer enhancer = new Enhancer();
        //2.设置父类(目标类),setSuperclass()方法,底层是创建目标类的子类
        enhancer.setSuperclass(XJJ.class);
        //3.设置回调函数enhancer.setCallback(new MethodInterceptor())
        enhancer.setCallback(new MethodInterceptor() {
            /**
             *
             * @param o 代理对象
             * @param method 正在执行的目标方法对象
             * @param objects 方法的实参
             * @param methodProxy 方法得当代理对象
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println("执行目标方法之前-->"+method.getName());
                Object invoke = method.invoke(XJJ.class.newInstance(), (double)objects[0]/2);
                //invoke就是方法的返回值
                System.out.println("执行目标方法之后-->"+invoke);
                return invoke;
            }
        });
        //4.创建代理对象create()方法
        XJJ o = (XJJ) enhancer.create();
        //5.测试
        o.workInDay(1000);
        o.workInNight(1500);
    }
}

6.4 AOP的开发中的相关术语

1. Joinpoint(连接点) – 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点
2. Pointcut(切入点) – 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
3. Advice(通知/增强) – 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能) 通知就定义了，需要做什么，以及在某个连接点的什么时候做。 上面的切点定义了在哪里做
4. Introduction(引介) – 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field
5. Target(目标对象) – 代理的目标对象
6. Weaving(织入) – 是指把增强应用到目标对象来创建新的代理对象的过程
7. Proxy（代理） – 一个类被AOP织入增强后，就产生一个结果代理类
8. Aspect(切面) – 是切入点和通知的结合，以后咱们自己来编写和配置的

6.5 spring aop编程

public interface UserService {
    int add();
    void delete();
    void update();
    void query();
}

public class UserServiceImpl implements UserService {

    @Override
    public int add() {
        System.out.println("add");
        return 100;
    }

    @Override
    public void delete() {
        System.out.println("delete");
    }

    @Override
    public void update() {
        System.out.println("update");
    }

    @Override
    public void query() {
        System.out.println("query");
    }
}

/**
 * 环绕通知 org.aopalliance.intercept.MethodInterceptor
 * 在目标方法执行前后实施增强
 */

public class MyAdvice implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation methodInvocation) {
        Object o = null;
        try {
            System.out.println("前置通知-->" + methodInvocation.getMethod().getName());
            o = methodInvocation.proceed();//执行目标方法
            System.out.println("后置通知-->" + o);//获得方法的返回值
        } catch (Throwable throwable) {
            System.out.println("异常通知-->");//回滚事物
            throwable.printStackTrace();
        } finally {
            //提交事物,释放资源
            System.out.println("最终通知-->");
            return o;
        }
    }
}

    <!--配置目标类-->
    <bean id="userService" class="aop.service.impl.UserServiceImpl"/>
    <!--配置通知类-->
    <bean id="myAdvice" class="aop.MyAdvice"/>
    <!--aop配置
    proxy-target-class:默认会根据目标类有无接口来进行选用jdk的动态还是cglib动态代理，有接口选jdk的动态代理，无选择cglib动态代理。
    指定true:强制使用cglib
    -->
    <aop:config proxy-target-class="true">
        <!--配置切点表达式，根据该切点表达式可以找到你要拦截的类的方法
            id;指定id
            expression:切点表达式
            execution(public * aop.service.impl.*.*(..))
            public指方法的访问权限修饰符  默认public可以不写
            *表示方法的返回值是任意的。int  String  void  ....
            aop.service.impl:指拦截的包路径
            *:第一个*表示包下面的任意类
            *：表示该包下面的任意方法
            (..):表示方法的形参任意
        -->
        <aop:pointcut id="cut" expression="execution(* aop.service.impl.*.add*(..))"/>
        <aop:pointcut id="cut2" expression="execution(* aop.service.impl.*.delete*(..))"/>
        <!--配置切面
        advice-ref:指向通知的id
        pointcut-ref:指向切点表达式的id
        -->
        <aop:advisor advice-ref="myAdvice" pointcut-ref="cut"/>
        <aop:advisor advice-ref="myAdvice" pointcut-ref="cut2"/>
    </aop:config>
</beans>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:aop/spring-aop.xml")
public class DemoAop {
    @Autowired
    private UserService userService;

    @Test
    public void run(){
        userService.add();
        userService.delete();
        userService.update();
        userService.query();
    }
}

6.6 AspectJ编程

6.6.1 AspectJ介绍

• AspectJ是一个基于Java语言的AOP框架

• Spring2.0以后新增了对AspectJ切点表达式支持

• @AspectJ 是AspectJ1.5新增功能，通过JDK5注解技术，允许直接在Bean类中定义切面

• 主要用途：自定义开发

新版本Spring框架，建议使用AspectJ方式来开发AOP

6.6.2 AspectJ 通知类型

• aop联盟定义通知类型，具有特性接口，必须实现，从而确定方法名称。

• aspectj 通知类型，只定义类型名称。方法格式。

6.6.3 基于xml实现

编写切面类

//Aspectj AOP编程的通知只声明方法的形式 不需要接口实现
public class MyAdvice {
    //前置通知
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知-->"+joinPoint.getSignature().getName());
    }
    //后置通知  获得方法的返回值
    //Object res  第二个形参表示方法的返回值  参数名需要进行配置
    public void afterReturing(JoinPoint joinPoint,Object res){
        System.out.println(res+"后置通知-->"+joinPoint.getSignature().getName());
    }
    //异常通知
    //Throwable e 表示异常对象  形参名需要配置
    public void afterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println(e.getMessage()+"异常通知-->"+joinPoint.getSignature().getName());
    }
    //最终通知
    public void after(){
        System.out.println("最终通知-->");
    }
    //环绕通知
    public Object around(ProceedingJoinPoint joinPoint){
        Object proceed=null;
        try {
            System.out.println("around-->前置通知");
            //手动执行目标方法
            proceed = joinPoint.proceed();
            System.out.println("around-->后置通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("around-->异常通知");
        }finally {
            System.out.println("around-->最终通知");
            return proceed;
        }
    }
}

编写目标类

public interface UserService {
    void  add();
}

public class UserServiceImpl implements UserService {
    @Override
    public void add() {
        System.out.println("UserServiceImpl.add");
    }
}

切面类 aop的配置

<bean id="userService" class="aspectj.service.impl.UserServiceImpl"/>
<bean id="myAdvice" class="aspectj.MyAdvice"/>
<!--aop配置-->
<aop:config>
    <!--配置一个公共的切点表达式-->
    <aop:pointcut id="cut" expression="execution(* aspectj.service.impl.*.*(..))"/>
    <aop:aspect ref="myAdvice">
        <!--<aop:before method="myBefore" pointcut-ref="cut"/>-->
        <!--这里自己配置切点表达式-->
       <!-- <aop:after-returning method="afterReturing" pointcut="execution(* aspectj.service.impl.*.*(..))" returning="res"/>
        <aop:after-throwing method="afterThrowing" pointcut-ref="cut" throwing="e"/>
        <aop:after method="after" pointcut-ref="cut"/>-->
        <aop:around method="around" pointcut-ref="cut"/>
    </aop:aspect>
</aop:config>

测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:aspectj/spring-aspectj.xml")
public class DemoApsectj {
    @Autowired
    private UserService userService;
    @Test
    public void run(){
        userService.add();
    }
}
环绕通知输出:
around-->前置通知
UserServiceImpl.add
around-->后置通知
around-->最终通知

6.6.4 基于注解

切面类 aop的配置

<!--开启注解扫描-->
<context:component-scan base-package="aspectj_anno"/>
<!--开启aop注解-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

修改实现类使用注解

修改切面类

//Aspect 声明切面，修饰切面类，从而获得通知
@Component//<bean id="myAdvice" class="aspectj.MyAdvice"/>
@Aspect//<aop:aspect ref="myAdvice">
public class MyAdvice {
    //配置一个公共的切点表达式
    @Pointcut("execution(* aspectj_anno.service.impl.*.*(..))")
    public void myCut(){}

    //前置通知<aop:before method="myBefore" pointcut="execution(* aspectj_anno.service.impl.*.*(..))"/>
    @Before("execution(* aspectj_anno.service.impl.*.*(..))")
    public void myBefore(JoinPoint joinPoint){
        System.out.println("前置通知-->"+joinPoint.getSignature().getName());
    }
    //后置通知  获得方法的返回值
    //Object res  第二个形参表示方法的返回值  参数名需要进行配置
    @AfterReturning(value = "execution(* aspectj_anno.service.impl.*.*(..))",returning = "res")
    public void afterReturing(JoinPoint joinPoint,Object res){
        System.out.println(res+"后置通知-->"+joinPoint.getSignature().getName());
    }
    //异常通知
    //Throwable e 表示异常对象  形参名需要配置
    @AfterThrowing(value="myCut()",throwing = "e")
    public void afterThrowing(JoinPoint joinPoint,Throwable e){
        System.out.println(e.getMessage()+"异常通知-->"+joinPoint.getSignature().getName());
    }
    //最终通知
    @After("myCut()")
    public void after(){
        System.out.println("最终通知-->");
    }
    //环绕通知
    @Around("myCut()")
    public Object around(ProceedingJoinPoint joinPoint){
        Object proceed=null;
        try {
            System.out.println("around-->前置通知");
            //手动执行目标方法
            proceed = joinPoint.proceed();
            System.out.println("around-->后置通知");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
            System.out.println("around-->异常通知");
        }finally {
            System.out.println("around-->最终通知");
            return proceed;
        }
    }
}

测试类同上,结果如下

around-->前置通知
前置通知-->add
UserServiceImpl.add
around-->后置通知
around-->最终通知
最终通知-->
null后置通知-->add

七、事务

7.1 Spring JDBC 数据访问

Spring JDBC是Spring所提供的持久层技术,它的主要目标是降低使用JDBC API的门槛,以一种更直接,更简介,更简单的方式使用JDBC API, 在Spring JDBC里,仅需做那些与业务相关的DML操作,而将资源获取,Statment创建,资源释放以及异常处理等繁杂而乏味的工作交给Spring JDBC.

虽然ORM的框架已经成熟丰富,但是JDBC的灵活,直接的特性,依然让他拥有自己的用武之地,如在完全依赖查询模型动态产生查询语句的综合查询系统中,Hibernaye,MyBatis,JPA等框架都无法使用,这里JDBC是唯一的选择.

导入相关的包

7.2 JdbcTemplate的简单使用

public class DemoJdbcTemplate {
    /**
     * spring给我们提供了一个类：JdbcTemplate
     * jdbcTemplate.queryForObject(); 返回对象
     * jdbcTemplate.query(); 返回一个List
     * jdbcTemplate.update(); 新增、修改、删除
     */
    @Test
    public void run() throws PropertyVetoException {
        //创建c3p0链接池
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        //设置必要的信息
        dataSource.setJdbcUrl("jdbc:mysql:///mydb?serverTimezone=GMT%2B8");
        dataSource.setUser("root");
        dataSource.setPassword("1111");
        dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
        //创建jdbcTemplate对象
        JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
        jdbcTemplate.update("insert into user(uname,upwd) values (?,?)", "chen", "1234");
    }
}

7.3 使用Spring管理JdbcTemplate

1.创建User类

@Getter
@Setter
@ToString
public class User {
    private int uid;
    private String uname;
    private String upwd;
    private Date birthday;

}

2.创建UserDao接口

public interface UserDao {
    int add(User user);//增
    int deleteById(int uid);//删
    int update(User user);//改
    User queryById(int uid);//查
    List<User> queryAll();//查询所有
    int count();//查询条数
}

3.创建UserDaoImpl类

@Repository
public class UserDaoImpl implements UserDao {
    @Autowired //自动装配
    private JdbcTemplate jdbcTemplate;

    @Override
    public int add(User user) {
        return jdbcTemplate.update("insert into user(uname,upwd) values (?,?)", user.getUname(), user.getUpwd());
    }

    @Override
    public int deleteById(int uid) {
        return jdbcTemplate.update("delete from user where uid=?", uid);
    }

    @Override
    public int update(User user) {
        return jdbcTemplate.update("update user set uname=? where uid=?", user.getUname(), user.getUid());

    }

    /**
     * BeanPropertyRowMapper 可以把结果集封装到对象里面
     * 通过属性名和列名一致来调用setter进行设置值。
     */
    @Override
    public User queryById(int uid) {
        return jdbcTemplate.queryForObject("select * from user where uid=?",
                new BeanPropertyRowMapper<>(User.class),uid);
    }

    @Override
    public List<User> queryAll() {
        return jdbcTemplate.query("select * from user",new BeanPropertyRowMapper<>(User.class));
    }

    @Override
    public int count() {
        return jdbcTemplate.queryForObject("select count(uid) from user",Integer.class);
    }
}

4.配置spring-jdbc.xml

<!--加载db.properties-->
<context:property-placeholder location="classpath:db.properties"/>
<!--开启注解扫描-->
<context:component-scan base-package="jdbctemplate2"/>
<!--配置数据源-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
      p:user="${jdbc.user}"
      p:password="${jdbc.password}"
      p:jdbcUrl="${jdbc.url}"
      p:driverClass="${jdbc.driverClass}"/>
<!--配置jdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"
      p:dataSource-ref="dataSource"/>

5.测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:jdbctemplate2/spring-jdbc.xml")
public class DemoJdbcTemplate {
    @Autowired
    private UserDao userDao;
    @Test
    public void runAdd(){
        User user=new User();
        user.setUname("chen");
        user.setUpwd("1213");
        int row = userDao.add(user);
        System.out.println("row = " + row);
    }
    @Test
    public void runDelete(){
        int row = userDao.deleteById(5);
        System.out.println("row = " + row);
    }
    @Test
    public void runUpdate(){
        User user=new User();
        user.setUid(3);
        user.setUname("chen");
        int row = userDao.update(user);
        System.out.println("row = " + row);
    }
    @Test
    public void runQueryObject(){
        User user = userDao.queryById(1);
        System.out.println("user = " + user);
    }
    @Test
    public void runQueryAll(){
        List<User> users = userDao.queryAll();
        System.out.println(users);
    }
    @Test
    public void runQueryCount(){
        System.out.println(userDao.count());
    }
}

使用JdbcDaoSupport,可以让我们的dao继承JdbcDaoSupport，然后注入DataSource或者JdbcTemplate，我们可以抽取一个BaseDao父类：让我们的dao类继承 BaseDao

@Component
public class BaseDao extends JdbcDaoSupport {
    @Autowired
    private DataSource dataSource;
    //在该类初始化的时候,给父类设置dataSource
    @PostConstruct
    public void init(){
        System.out.println("BaseDao.init");
        super.setDataSource(dataSource);
    }
}

@Repository
public class UserDaoImpl2 extends BaseDao implements UserDao {
//JdbcDaoSupport是Spring给我们提供的一个类，我们可以让我们的dao类继承该类 然后给该类输入数据源或者模板类
    @Override
    public int add(User user) {
        return this.getJdbcTemplate().update("insert into user(uname,upwd) values (?,?)", user.getUname(), user.getUpwd());
    }

    @Override
    public int deleteById(int uid) {

        return this.getJdbcTemplate().update("delete from user where uid=?", uid);
    }

    @Override
    public int update(User user) {

        return this.getJdbcTemplate().update("update user set uname=? where uid=?", user.getUname(), user.getUid());

    }


    @Override
    public User queryById(int uid) {
        return this.getJdbcTemplate().queryForObject("select * from user where uid=?",
                new BeanPropertyRowMapper<>(User.class),uid);
    }

    @Override
    public List<User> queryAll() {
        return this.getJdbcTemplate().query("select * from user",new BeanPropertyRowMapper<>(User.class));
    }

    @Override
    public int count() {
        return this.getJdbcTemplate().queryForObject("select count(uid) from user",Integer.class);
    }
}

配置spring-jdbc.xml

<context:property-placeholder location="db.properties"/>
<context:component-scan base-package="jdbctemplate2"/>
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
      p:user="${jdbc.user}"
      p:password="${jdbc.password}"
      p:jdbcUrl="${jdbc.url}"
      p:driverClass="${jdbc.driverClass}"/>

测试类同上

7.4 Spring事务管理

​ 事务的第一个方面是传播行为（propagation behavior）。当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。Spring定义了七种传播行为：(一般只需掌握前两种)

• PROPAGATION_REQUIRED
  表示当前方法必须运行在事务中。如果当前事务存在，方法将会在该事务中运行。否则，会启动一个新的事务

• PROPAGATION_SUPPORTS
  表示当前方法不需要事务上下文，但是如果存在当前事务的话，那么该方法会在这个事务中运行

• PROPAGATION_MANDATORY
  表示该方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常

• PROPAGATION_REQUIRED_NEW
  表示当前方法必须运行在它自己的事务中。一个新的事务将被启动。如果存在当前事务，在该方法执行期间，当前事务会被挂起

• PROPAGATION_NOT_SUPPORTED
  表示该方法不应该运行在事务中。如果存在当前事务，在该方法运行期间，当前事务将被挂起。

• PROPAGATION_NEVER
  表示当前方法不应该运行在事务上下文中。如果当前正有一个事务在运行，则会抛出异常

• PROPAGATION_NESTED
  表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在，那么其行为与PROPAGATION_REQUIRED一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的文档来确认它们是否支持嵌套事务

事务的特性

ACID

1 - 原子性（atomicity）

事务是数据库的逻辑工作单位，而且是必须是原子工作单位，对于其数据修改，要么全部执行，要么全部不执行。

2、一致性（consistency）

事务在完成时，必须是所有的数据都保持一致状态。在相关数据库中，所有规则都必须应用于事务的修改，以保持所有数据的完整性。

3、隔离性（isolation）

一个事务的执行不能被其他事务所影响。企业级的数据库每一秒钟都可能应付成千上万的并发访问，因而带来了并发控制的问题。由数据库理论可知，由于并发访问，在不可预料的时刻可能引发如下几个可以预料的问题：（见“二、事务的并发问题“）

4、持久性（durability）

一个事务一旦提交，事物的操作便永久性的保存在DB中。即使此时再执行回滚操作也不能撤消所做的更改

事务的并发问题

1、脏读（Dirty Read）

一个事务读取到了另一个事务未提交的数据操作结果。这是相当危险的，因为很可能所有的操作都被回滚。

2、不可重复读（虚读）（NonRepeatable Read）

一个事务对同一行数据重复读取两次，但是却得到了不同的结果。例如事务T1读取某一数据后，事务T2对其做了修改，当事务T1再次读该数据时得到与前一次不同的值。

3、幻读（Phantom Read）

事务在操作过程中进行两次查询，第二次查询的结果包含了第一次查询中未出现的数据或者缺少了第一次查询中出现的数据，这是因为在两次查询过程中有另外一个事务插入数据造成的

事务的隔离级别

1、读未提交 Read uncommitted：最低级别，以上情况均无法保证。

2、读已提交 Read committed：可避免脏读情况发生。

4、可重复读 Repeatable read：可避免脏读、不可重复读情况的发生。不可以避免幻读。

8、串行化读 Serializable：事务只能一个一个执行，避免了脏读、不可重复读、幻读。执行效率慢，使用时慎重

7.4.1 转账案例

1.项目名:spring-tx 引入jar包 复制数据库配置db.properties

2.创建数据库

3.创建dao接口

public interface AccountDao {
    int descMoney(int from,double money);
    int addMoney(int to,double money);
}

4.创建dao实现类

@Repository
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public int descMoney(int from, double money) {
        String sql="update account set money=money-? where id=?";
        return jdbcTemplate.update(sql,money,from);
    }

    @Override
    public int addMoney(int to, double money) {
        String sql="update account set money=money+? where id=?";
        return jdbcTemplate.update(sql,money,to);
    }
}

5.创建service接口

public interface AccountService {//转账业务
    boolean transfer(int from,int to,double money);
}

6.创建service实现类

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    @Override
    public boolean transfer(Integer from, Integer to, Double money) {
        accountDao.descMoney(from,money);
        accountDao.addMoney(to,money);
        return true;
    }
}

7.添加ioc配置文件

<?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" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:tx="http://www.springframework.org/schema/tx" xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <context:property-placeholder location="db.properties"/>
    <context:component-scan base-package="spring_tx"/>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
          p:user="${jdbc.user}"
          p:password="${jdbc.password}"
          p:jdbcUrl="${jdbc.url}"
          p:driverClass="${jdbc.driverClass}"/>
    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--1.配置平台事物管理器
    DataSourceTransactionManager 用于 JDBC和mybatis 的事务管理
    HibernateTransactionManager 用于 Hibernate 的事务管理
    JpaTransactionManager 用于 Jpa 的事务管理 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--2.配置事务详情/属性 (传播行为 超时时间 是否可读)-->
    <!--配置事务通知/属性:transaction-manager="transactionManager"：指向事务平台管理器-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--配置事务属性-->
        <tx:attributes>
            <!--
            tx:method配置事务方法
            propagation:事务的传播行为 一般增删改配置REQUIRED 查询配置SUPPORTS
            isolation:隔离级别 一般默认不配置
            timeout="-1" 默认-1 采取数据库默认的超时时间 一般默认不配置
            read-only="false"：是否只读  默认false 查询配置true
            no-rollback-for:遇到什么异常不回滚  一般默认不配置
            rollback-for：遇到什么异常回滚  一般默认不配置
            name:配置的方法名 采取通配符的方式 配置业务层的方法名 事务在业务层开启
            -->
            <tx:method name="add*" propagation="REQUIRED"/>
            <tx:method name="delete*" propagation="REQUIRED"/>
            <tx:method name="update*" propagation="REQUIRED"/>
            <tx:method name="modify*" propagation="REQUIRED"/>
            <tx:method name="trans*" propagation="REQUIRED"/>
            <tx:method name="change*" propagation="REQUIRED"/>
            <tx:method name="query*" propagation="SUPPORTS" read-only="true"/>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>
    <!--3.aop编程-->
    <aop:config>
        <aop:pointcut id="cut" expression="execution(* spring_tx.service.impl.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="cut"/>
    </aop:config>
</beans>

8.测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:spring_tx/spring-tx.xml")
public class DemoTransfer {
    @Autowired
    private AccountService accountService;
    @Test
    public void run(){
        boolean transfer = accountService.transfer(1, 2, (double) 500);
        System.out.println("transfer = " + transfer);
    }
}

7.4.2 Spring XML配置声明事务

TransactionManager

在不同平台，操作事务的代码各不相同，因此spring提供了一个 TransactionManager 接口：

• DataSourceTransactionManager 用于 JDBC和mybatis 的事务管理

• HibernateTransactionManager 用于 Hibernate 的事务管理

• JpaTransactionManager 用于 Jpa 的事务管理

接口的定义

事务的属性介绍：这里定义了传播行为、隔离级别、超时时间、是否只读

package org.springframework.transaction;
public interface TransactionDefinition {
    int PROPAGATION_REQUIRED = 0; //支持当前事务，如果不存在，就新建一个
    int PROPAGATION_SUPPORTS = 1; //支持当前事务，如果不存在，就不使用事务
    int PROPAGATION_MANDATORY = 2; //支持当前事务，如果不存在，就抛出异常
    int PROPAGATION_REQUIRES_NEW = 3;//如果有事务存在，挂起当前事务，创建一个新的事物
    int PROPAGATION_NOT_SUPPORTED = 4;//以非事务方式运行，如果有事务存在，挂起当前事务
    int PROPAGATION_NEVER = 5;//以非事务方式运行，如果有事务存在，就抛出异常
    int PROPAGATION_NESTED = 6;//如果有事务存在，则嵌套事务执行
    
    int ISOLATION_DEFAULT = -1;//默认级别，MYSQL: 默认为REPEATABLE_READ级别 SQLSERVER: 默认为READ_COMMITTED
    int ISOLATION_READ_UNCOMMITTED = 1;//读取未提交数据(会出现脏读, 不可重复读) 基本不使用
    int ISOLATION_READ_COMMITTED = 2;//读取已提交数据(会出现不可重复读和幻读)
    int ISOLATION_REPEATABLE_READ = 4;//可重复读(会出现幻读)
    int ISOLATION_SERIALIZABLE = 8;//串行化
    
    int TIMEOUT_DEFAULT = -1;//默认是-1，不超时，单位是秒

    //事务的传播行为
    int getPropagationBehavior();
    //事务的隔离级别
    int getIsolationLevel();
    //事务超时时间
    int getTimeout();
    //是否只读
    boolean isReadOnly();
    String getName();
}

7.4.3 编程式的事务管理(了解)

7.5.4 使用注解方式添加事务

修改service实现类添加@Transactional注解

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    @Override
    @Transactional//既可以写在方法上  也可以写在类上  写在类上表示该类的所有方法都加事务
//    @Transactional(rollbackFor = {Exception.class})//阿里规范写法,需指定rollbackFor
//    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.DEFAULT,timeout = -1,readOnly = false,
//            rollbackFor = {Exception.class},noRollbackFor = {})
    public boolean transfer(Integer from, Integer to, Double money) {
        accountDao.descMoney(from,money);
        accountDao.addMoney(to,money);
        return true;
    }
}

配置xml

    <context:property-placeholder location="db.properties"/>
    <context:component-scan base-package="spring_tx_anno"/>
    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
          p:user="${jdbc.user}"
          p:password="${jdbc.password}"
          p:jdbcUrl="${jdbc.url}"
          p:driverClass="${jdbc.driverClass}"/>
    <!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--配置平台事物管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--开启事务驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

测试类同上

附录：Spring模块介绍

1、core - 核心模块

• spring-core：依赖注入IoC与DI的最基本实现
• spring-beans：Bean工厂与bean的装配
• spring-context：spring的context上下文即IoC容器
• spring-context-support
• spring-expression：spring表达式语言

详细说明

（1）spring-core

这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类

（2）spring-beans

这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring- beans.jar文件就可以了

（3）spring-context

Spring核心提供了大量扩展，这样使得由 Core 和 Beans 提供的基础功能增强：这意味着Spring 工程能以框架模式访问对象。Context 模块继承了Beans 模块的特性并增加了对国际化（例如资源绑定）、事件传播、资源加载和context 透明化（例如 Servlet container）。同时，也支持JAVA EE 特性，例如 EJB、 JMX 和 基本的远程访问。Context 模块的关键是 ApplicationContext 接口。spring-context-support 则提供了对第三方库集成到 Spring-context 的支持，比如缓存（EhCache, Guava, JCache）、邮件（JavaMail）、调度（CommonJ, Quartz）、模板引擎（FreeMarker, JasperReports, Velocity）等。

（4）spring-expression

为在运行时查询和操作对象图提供了强大的表达式语言。它是JSP2.1规范中定义的统一表达式语言的扩展，支持 set 和 get 属性值、属性赋值、方法调用、访问数组集合及索引的内容、逻辑算术运算、命名变量、通过名字从Spring IoC容器检索对象，还支持列表的投影、选择以及聚合等。

2、Data Access/Integration - 数据访问与集成

数据访问与集成层包含 JDBC、ORM、OXM、JMS和事务模块。

详细说明

（1）spring-jdbc

提供了 JDBC抽象层，它消除了冗长的 JDBC 编码和对数据库供应商特定错误代码的解析。

（2）spring-tx

支持编程式事务和声明式事务，可用于实现了特定接口的类和所有的 POJO 对象。编程式事务需要自己写beginTransaction()、commit()、rollback()等事务管理方法，声明式事务是通过注解或配置由 spring 自动处理，编程式事务粒度更细。

（3）spring-orm

提供了对流行的对象关系映射 API的集成，包括 JPA、JDO 和 Hibernate 等。通过此模块可以让这些 ORM 框架和 spring 的其它功能整合，比如前面提及的事务管理。

（4）spring-oxm

模块提供了对 OXM 实现的支持，比如JAXB、Castor、XML Beans、JiBX、XStream等。

（5）spring-jms

模块包含生产（produce）和消费（consume）消息的功能。从Spring 4.1开始，集成了 spring-messaging 模块

3、Web

Web 层包括 spring-web、spring-webmvc、spring-websocket、spring-webmvc-portlet 等模块。

详细说明

（1）spring-web

提供面向 web 的基本功能和面向 web 的应用上下文，比如 multipart 文件上传功能、使用 Servlet 监听器初始化 IoC 容器等。它还包括 HTTP 客户端以及 Spring 远程调用中与 web 相关的部分

（2）spring-webmvc

为 web 应用提供了模型视图控制（MVC）和 REST Web 服务的实现。Spring 的 MVC 框架可以使领域模型代码和 web 表单完全地分离，且可以与 Spring 框架的其它所有功能进行集成

（3）spring-webmvc-portlet

（即Web-Portlet模块）提供了用于 Portlet 环境的 MVC 实现，并反映了 pring-webmvc 模块的功能

4、AOP

（1）spring-aop

提供了面向切面编程（AOP）的实现，可以定义诸如方法拦截器和切入点等，从而使实现功能的代码彻底的解耦。使用源码级的元数据。

（2）spring-aspects

提供了对 AspectJ 的集成

5、Instrumentation

（1）spring-instrument

模块提供了对检测类的支持和用于特定的应用服务器的类加载器的实现。

（2）spring-instrument-tomcat

模块包含了用于 Tomcat 的Spring 检测代理。

6、Messaging - 消息处理

spring-messaging 模块

从 Spring 4 开始集成，从一些 Spring 集成项目的关键抽象中提取出来的。这些项目包括 Message、MessageChannel、MessageHandler 和其它服务于消息处理的项目。这个模块也包含一系列的注解用于映射消息到方法

7、Test

spring-test 模块

通过 JUnit 和 TestNG 组件支持单元测试和集成测试。它提供了一致性地加载和缓存 Spring 上下文，也提供了用于单独测试代码的模拟对象（mock object）

SpringMVC

一.Spring MVC 简介

大部分Java应用都是Web应用,展现层是WEB应用不可忽略的重要环节.Spring为了展现层提供了一个优秀的WEB框架-Spring MVC . 和众多的其他WEB框架一样,它基于MVC的设计理念. 此外,它采用了松散耦合,可插拔的组件结构,比其他的MVC框架更具有扩展性和灵活性,Spring MVC通过一套MVC注解,让POJO成为成为处理请求的处理器,无须实现任何接口.同时,Spring MVC还支持REST风格的URL请求:注解驱动及REST风格的Spring MVC是Spring的出色功能之一.

此外,Spring MVC在数据绑定,视图解析,本地化处理及静态资源处理上都有许多不俗的表现,它在框架设计,可扩展,灵活性等方面全面超越了Struts,WebWork等MVC框架,从原来的追赶者一跃成为了MVC的领跑者.

1.1 MVC模式简介

​ MVC全名是Model View Controller，是模型(model)－视图(view)－控制器(controller)的缩写，一种软件设计典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。MVC被独特的发展起来用于映射传统的输入、处理和输出功能在一个逻辑的图形化用户界面的结构中。

MVC 是一种使用 MVC（Model View Controller 模型-视图-控制器）设计创建 Web 应用程序的模式：[1]

• Model（模型）表示应用程序核心（比如数据库记录列表）。
• View（视图）显示数据（数据库记录）。
• Controller（控制器）处理输入（写入数据库记录）。

MVC 模式同时提供了对 HTML、CSS 和 JavaScript 的完全控制。

**Model（模型）**是应用程序中用于处理应用程序数据逻辑的部分。
　　通常模型对象负责在数据库中存取数据。

**View（视图）**是应用程序中处理数据显示的部分。
　　通常视图是依据模型数据创建的。

**Controller（控制器）**是应用程序中处理用户交互的部分。
　　通常控制器负责从视图读取数据，控制用户输入，并向模型发送数据。

MVC 分层有助于管理复杂的应用程序，因为您可以在一个时间内专门关注一个方面。例如，您可以在不依赖业务逻辑的情况下专注于视图设计。同时也让应用程序的测试更加容易。

MVC 分层同时也简化了分组开发。不同的开发人员可同时开发视图、控制器逻辑和业务逻辑。

1.2 Spring MVC 体系结构

Spring MVC是基于 Model 2实现的技术框架,Model 2是经典的MVC(model,view,control)模型在WEB应用中的变体.这个改变主要源于HTTP协议的无状态性,Model 2 的目的和MVC一样,也是利用处理器分离模型,视图和控制,达到不同技术层级间松散层耦合的效果,提高系统灵活性,复用性和可维护性.大多情况下,可以将Model 2 与 MVC等同起来.

Spring MVC体系概述

​ Spring MVC框架围绕DispatcherServlet这个核心展开,DispatcherServlet是Spring MVC的总导演,总策划.它负责截获请求并将其分派给相应的处理器处理.Spring MVC框架包括注解驱动控制器,请求及响应的信息处理,视图解析,本地化解析,上传文件解析,异常处理及表单标签绑定内容等…

Spring核心组件

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-av6O08Q1-1575040207827)(images/mvc-context-hierarchy.png)]

组件介绍

DispatcherServlet：作为前端控制器，整个流程控制的中心，控制其它组件执行，统一调度，降低组件之间的耦合性，提高每个组件的扩展性。

HandlerMapping：通过扩展处理器映射器实现不同的映射方式，例如：配置文件方式，实现接口方式，注解方式等。

HandlAdapter：通过扩展处理器适配器，支持更多类型的处理器,调用处理器传递参数等工作!

ViewResolver：通过扩展视图解析器，支持更多类型的视图解析，例如：jsp、freemarker、pdf、excel等。

1.3 Spring MVC执行流程

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cH9VrPNm-1575040207828)(images/springmvc支持流程图.png)]

​ 从接收请求到响应,Spring MVC框架的众多组件通力配合,各司其职,有条不紊的完成分内工作!在整个框架中,DispatchserServlet处于核心的位置,它负责协调和组织不同组件以完成请求处理以及返回影响工作.和大多数Web MVC框架一样,Spring MVC 通过一个前段的Servlet接收所有请求,并将这些工作委托给其他组件进行处理,DispatcherServlet 就是Spring MVC的前段Servlet。下面对Spring MVC处理请求的整体过程进行详解!

1. 整个过程始于客户端发出的一个HTTP请求,WEB应用服务器接收到这个请求，如果匹配DispatcherServlet的映请求映射路径(web.xml中指定),则Web容器将该请求转交给DispatcherServlet处理。
2. 接收到这个请求后,将根据请求的信息(包括 URL,HTTP方法,请求头,请求参数,Cookie等)及HandlerMapping的配置找到处理请求的处理器(Handler)。可将HandlerMapping看做路由控制器,将Handler看做目标主机.值得注意的是,在Spring MVC中并没有定义一个Handler接口,实际上,任何一个Object都可以成为请求处理器。
3. 当DispatcherServlet根据HandlerMapping得到对应当前请求的Handler后,通过HandlerAdapter对Handler的封装,再以统一的适配器接口调用Handler。HandlerAdapter是Spring MVC的框架级接口,顾名思义,HandlerAdapter是一个适配器,它用统一的接口对各种Handler的方法进行调用.
4. 处理器完成业务逻辑的处理后将返回一个ModelAndView给DispatcherServlet,ModelAndView包含了视图逻辑名和模型数据信息。
5. ModelAndView中包含的是"逻辑视图名"而并非真正的视图对象,DispatcherServlet借由ViewResolver完成逻辑视图名到真实视图对象的解析工作。
6. 当得到真实的视图对象View后,DispatcherServlet就使用这个View对象对ModelAndView中的模型数据进行视图渲染。
7. 最终客户端得到的响应信息可能是一个普通的HTML页面,也可能是一个XML或者JSON串,甚至是一张图片或者一个PDF文档等不同的媒体形式。

1.4 组件开发实现情况

1、前端控制器DispatcherServlet（不需要工程师开发）,由框架提供
作用：接收请求，响应结果，相当于转发器，中央处理器。有了dispatcherServlet减少了其它组件之间的耦合度。需要在web.xml里面进行配置。
用户请求到达前端控制器，它就相当于mvc模式中的c，dispatcherServlet是整个流程控制的中心，由它调用其它组件处理用户的请求，dispatcherServlet的存在降低了组件之间的耦合性。

2、处理器映射器HandlerMapping(不需要工程师开发),由框架提供
作用：根据的url来和注解或者xml进行匹配来找到目标handler.
找到以后返回给前端控制器一个执行器链（包括目标handler和拦截器）。找不到报错404.需要在spirng的配置文件里面进行配置。

3、处理器适配器HandlerAdapter(不需要工程师开发)
作用：对目标handler进行适配。并且去执行目标handler，执行完成之后，返回一个ModelAdnView。
需要进行配置。在spirng的配置文件里面进行配置。

4、处理器Handler(需要工程师开发)
handler就是我们以前写的servlet程序。handler需要我们自己编写,提供相应的注解。

5、视图解析器View resolver(不需要工程师开发),由框架提供
把逻辑视图解析成真正的视图。返回给前端处理器。springmvc提供，需要进行配置，在spirng的配置文件里面。

6、视图ModelAdnView(需要工程师开发jsp…)
包含了数据和要跳转的页面。里面的视图是逻辑视图，还需要进行处理才能确定真正的视图。 springmvc提供，直接使用。

1.5 核心分发器DispatcherServlet

DispatcherServlet是Spring MVC的"灵魂"和"心脏",它负责接受HTTP请求并协调 Spring MVC的各个组件完成请求处理的工作。和任何Servlet一样,用户必须在web.xml中配置好DispatcherServlet。

1.5.1 DispatcherServlet介绍

​ DispatcherServlet是前端控制器设计模式的实现，提供spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。

1.5.2 DispatcherServlet主要职责

DispatcherServlet主要用作职责调度工作，本身主要用于控制流程，主要职责如下：

1. 文件上传解析，如果请求类型是multipart将通过MultipartResolver进行文件上传解析；
2. 通过HandlerMapping，将请求映射到处理器（返回一个HandlerExecutionChain，它包括一个处理器、多个HandlerInterceptor拦截器）；
3. 通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的处理器)；
4. 通过ViewResolver解析逻辑视图名到具体视图实现；
5. 本地化解析；
6. 渲染具体的视图等；
7. 如果执行过程中遇到异常将交给HandlerExceptionResolver来解析。

1.5.3 DispatcherServlet辅助类

​ spring中的DispatcherServlet使用一些特殊的bean来处理request请求和渲染合适的视图。这些bean就是Spring MVC中的一部分。你能够通过在WebApplicationContext中的一个或多个配置来使用这些特殊的bean。但是，你不需要在Spring MVC在维护这些默认要使用的bean时，去把那些没有配置过的bean都去初始化一道。在下一部分中，首先让我们看看在DispatcherServlet依赖的那些特殊bean类型

二、基于SpringMVC 的WEB应用

项目名: spring-mvc-base

maven项目pom配置:

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>cgp</groupId>
  <artifactId>spring-mvc</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>

  <name>spring-mvc Maven Webapp</name>
  <!-- FIXME change it to the project's website -->
  <url>http://www.example.com</url>


  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.6.RELEASE</version>
    </dependency>

  </dependencies>
  <build>
    <resources>
      <resource>
        <directory>src/main/java</directory>
        <includes>
          <include>**/*.*</include>
        </includes>
        <filtering>true</filtering>
      </resource>
      <resource>
        <directory>src/main/resources</directory>
        <includes>
          <include>**/*.*</include>
        </includes>
      </resource>
    </resources>
    <plugins>
      <plugin>
        <groupId>org.apache.tomcat.maven</groupId>
        <artifactId>tomcat7-maven-plugin</artifactId>
        <version>2.2</version>
        <configuration>
          <port>91</port>
          <path>/web</path>
          <uriEncoding>UTF-8</uriEncoding>
          <server>tomcat7</server>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>

2.1 配置web.xml

<servlet>
    <!--配置springmvc前端处理器DispatcherServlet-->
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

    <!--用来加载springmvc的配置文件-->
    <!--如果不配置,会默认加载/WEB-INF/<servlet-name>-servlet.xml文件-->
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <!--在服务器启动的时候就初始化该servlet-->
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <!--配置拦截路径
        /* --拦截所有请求  js jsp  html  css  img  控制器等 一般不使用
        /  --不拦截jsp   js HTML css  控制器等    强烈推荐
        *.action *.do   --只拦截指定后缀的请求  传统项目  crm  管理系统
    -->
    <url-pattern>/</url-pattern>
</servlet-mapping>

<!--解决post请求乱码-->
<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>
    <init-param>
        <param-name>forceEncoding</param-name>
        <param-value>true</param-value>
    </init-param>
</filter>

<filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

2.2 配置Spring MVC配置文件

<context:component-scan base-package="springmvc1.controller"/>

<!--配置处理器映射器-->
<!--<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>-->
<!--配置处理器适配器-->
<!--<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>-->

<!--MVC注解驱动 相当于以上两句 而且功能更强大-->
<mvc:annotation-driven/>

<!--配置视图解析器-->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!--配置前缀和后缀-->
    <property name="suffix" value=".jsp"/>
    <property name="prefix" value="/WEB-INF/jsp/"/>
</bean>

2.3 创建controller包以及控制器类

@Controller
public class HelloController {
    @RequestMapping("/hello") //相当于接收：http://ip:port/应用名/hello
    public String hello(){
        System.out.println("hello-->");
        //表示转发到页面  index是逻辑视图  加上前缀和后缀才是真正的视图  /WEB-INF/jsp/index.jsp
        return "index";
    }
}

2.4 测试Spring MVC

发布项目,通过浏览器,访问 当前项目对应地址+ /hello即可!

三、 常用注解

@RequestMapping注解应用

3.1.1 value属性

@Controller
@RequestMapping("cgp")//写在类上表示窄化请求,可不写
//@RequestMapping(value = "cgp")//方式二 value在只有一个参数的时候可不写
//@RequestMapping(value = {"cgp1","cgp2"})//方式三 可以写数组
public class Annotation {
    @RequestMapping("add") //窄化后路径为http://ip:port/项目根路径/cgp/add
    public String add(){
        System.out.println("Annotation.add");
        return "index";
    }
}

3.1.2 method属性

可以指定方法对应的请求方式!如果客户端请求的方式和方法设置的方式不同,请求不成功!

//method属性表示该方法支持的请求类型,不写的话任意请求都可以。常用四种请求方式:GET POST PUT DELETE
@RequestMapping(value = "add2",method = RequestMethod.GET)
//@RequestMapping(value = "add2",method = RequestMethod.POST)
//@RequestMapping(value = "add2",method = {RequestMethod.GET,RequestMethod.POST})
public String add2(){
    System.out.println("Annotation.add2");
    return "index";
}

3.1.3 表单参数处理

• 创建一个登陆表单

    <!--action指定controller中对应的方法路径即可!-->
    <form action="/xx/login" method="POST">
        <label for="username">用户名:<input type="text" name="username" /></label>
        <label for="password">密码:<input type="text" name="password" /></label>
        <input type="submit" value="登陆">
    </form>

• 获取参数的控制器

 @RequestMapping("login")
	//只需要在方法的形参里面写上参数，参数的名字要和表单的name属性值一样。
    public String login(String username,String password){
        System.out.println("username = " + username);
        System.out.println("password = " + password);
        return "index";
    }

• 获取特殊格式数据

//[username=chen&password=112&age=18&date=2012/12/12&hb=apple&hb=banana]
@RequestMapping("login")
//默认String字符串转化为Integer(不推荐int,因为当age参数不存在时,会返回null,而null不能转化为int,从而报错)
//日期默认支持格式:yyyy/MM/dd (2012/12/12) 自动转化为Date
//可以用String接收多选框数据,显示为 apple,banana 不过不推荐 一般用数组接收
//注意:如果格式无法转化会报400错误，如果出现400错误要注意检查在的参数是否匹配
public String login(String username, String password, Integer age, Date date, String[] hb) {
    System.out.println("username = " + username);//chen
    System.out.println("password = " + password);//112
    System.out.println("age = " + age);//18
    System.out.println("date = " + date);//Wed Dec 12 00:00:00 CST 2012
    System.out.println("hb = " + Arrays.toString(hb));//[apple, banana]
    return "index";
}

@RequestParam注解使用

开发中,也会碰到请求参数name的值与方法的参数名不同,这时就需要使用@RequestParam注解!

@RequestMapping("login")
//使用@RequestParam注解后,形参值就可以是任意名
//defaultValue设定默认值,当表单没有提交该数据时,会默设定该值
//多选框数据可以使用集合接收
public String login(@RequestParam(value="username")String name,
                    @RequestParam(value = "password",defaultValue = "1234") String pwd,
                    @RequestParam(value = "list")ArrayList<String> list) {
    System.out.println("name = " + name);
    System.out.println("pwd = " + pwd);
    System.out.println("list = " + list);//list = [apple, banana]
    return "index";
}

以后分页数据可以如下设置

@RequestMapping("/page")
public String queryPage(@RequestParam(defaultValue = "1")Integer currentPage,
                        @RequestParam(defaultValue = "10")Integer pageSize){
    return "index";
}

@PathVariable获取路径参数

我们可以通过此注解,获取路径部分的数据!

@RequestMapping("path/{id}")
//{id}表示占位符 (可以是任意字符)
//@PathVariable从路径里面获取数据 http://localhost:8080/mvc/cgp/path/hello
//获取路径/path/后面的hello数据
//只会解析一层 如果是path/hello/world 则会404
public String path(@PathVariable("id") String path) {
    System.out.println("path = " + path);//path = hello
    return "index";
}

@CookieValue

@RequestMapping("cookie")
public String cookie(@CookieValue("JSESSIONID")String cookie){
    System.out.println("cookie = " + cookie);//cookie = 25427660AB818EEFE1A27FCF71AD95BB
    return "index";
}

@RequestHeader

@RequestHeader注解可以获取请求头中的数据!!

@RequestMapping("header")
public String header(@RequestHeader("User-Agent")String header){
    System.out.println("header = " + header);
    return "index";
}

params请求表达式

通过表达式精准映射请求

• params和headers支持简单的表达式
  1. param:表示请求必须包含名为param的请求参数
  2. !param:表示请求中不能包含名为param的参数
  3. param != value:表示请求中包含param的请求参数,但是值不能为value
  4. param == value:表示请求中包含param的请求参数,但是值为value

 @RequestMapping(value = "/param" , params = {"!username","age!=10"})
 public String testParam(String usernam , Integer age){
     System.out.println("usernam:"+usernam);
     System.out.println("age:"+age);
     return "index";
 }

param 和 header

@RequestMapping(value = "/param1" ,headers={"Connection!=keep-alive"},params = {"!username","age!=10"})
public String testParam1(String usernam , Integer age){
     System.out.println("usernam:"+usernam);
     System.out.println("age:"+age);
     return "result";
}

ant风格的路径

ant风格资源地址支持3种匹配符:

1. ?:匹配文件名中的一个字符
2. *:匹配文件名中的任意字符
3. **:匹配多层路径

代码:

 @RequestMapping(value = "/?/*/xx" )

四、 其他重要操作

4.1. 转发和重定向

@Controller
public class Test {
    @RequestMapping("add")
    public String add() {
        System.out.println("Test.add");
        return "index";//转发到index.jsp 走视图解析器 可以转发到WEB-INF下的jsp
    }
    @RequestMapping("delete")
    public String delete() {
        System.out.println("Test.delete");
        return "forward:add";//转发到add控制器方法 不走视图解析器
    }
    
    @RequestMapping("query")
    public String query() {
        System.out.println("Test.query");
        return "redirect:delete";//重定向到控制器方法 不走视图解析器
    }
    @RequestMapping("update")
    public String update() {
        System.out.println("Test.update");
        return "redirect:login.jsp";//重定向到jsp页面 不走视图解析器 jsp页面一定不能放在WEB-INF下
    }
}

4.2. 解决参数乱码问题

Spring MVC中 GET方式不会乱码!

在web.xml配置文件中添加spring自带的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>
    <init-param>
      <param-name>forceEncoding</param-name>
      <param-value>true</param-value>
    </init-param>
  </filter>

  <filter-mapping>
    <filter-name>characterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>

五、向controller传递对象类型数据

通过form表单向指定的controller的方法传递对象!

5.1 创建POJO对象

POJO(Plain Ordinary Java Object)用来表示普通的Java对象，它不包含业务逻辑或持久逻辑等.

@Data
public class User {
    private String name;
    private Integer age;
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date date;
    private Address address;
}

public class Address {
    private String province;
    private String city;
    public Address() {}
    @Override
    public String toString() {...}
	getter() setter()
}

5.2 创建控制器类

@Controller
@RequestMapping("user")
public class UserController {
    @RequestMapping("form")
    public String form(){
        return "user/form";//跳转到form表单
    }
    @RequestMapping("add")
    public String add(User user){
        System.out.println("user = " + user);
        return "index";
    }
} 

5.3 创建form.jsp

文件位置: /WEB-INF/user/form.jsp

<form action="${pageContext.request.contextPath}/user/add" method="post">
	<%--<label> 标签作用:当用户选择该标签时，浏览器就会自动将焦点转到和标签相关的表单控件上。--%>
    <label for="name">用户名:<input type="text" id="name" name="name" /></label><br/>
    <label for="age">年龄:<input type="text" id="age" name="age" /></label><br/>
    <label for="date">生日:<input type="date" id="date" name="date" /></label><br/>
    <label for="address.province">省份:<input type="text" id="address.province" name="address.province" /></label><br/>
    <label for="address.city">城市:<input type="text" id="address.city" name="address.city" /></label><br/>
    <input type="submit"  value="提交" />
</form>

name属性要和User对象的属性相同

注意:name的特殊写法,这里可以直接将表单数据转成User对象,但是User对象内部包含 Address的对象,所以,这里可以调用第一层属性,再点一层属性,如果多层依次类推!

5.4 测试结果

user = User{name='chenganpin', age=12, date=Wed May 08 00:00:00 CST 2019, address=Address{province='浙江', city='温州'}}

六、 controller向页面传递数据

实现方案有三种: ModelAndView Map Model

往页面传递数据使用request域对象

6.1 ModelAndView

@RequestMapping("data1")
public ModelAndView request1() {
    User user = new User("cgp", 18, new Date(), new Address("浙江", "温州"));
    ModelAndView mav = new ModelAndView();
    mav.setViewName("index");//设置视图名字  逻辑视图  走视图解析器
    mav.addObject("user", user);//设置数据
    return mav;
}

页面显示代码:

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<html>
<head>
    <title>结果</title>
</head>
<body>
${requestScope.user}
<%--User{name='cgp', age=18, date=Wed May 08 19:08:27 CST 2019, address=Address{province='浙江', city='温州'}}--%>
<hr/>
${requestScope.user.date}
<%--Wed May 08 19:08:27 CST 2019--%>
<hr/>
<fmt:formatDate value="${requestScope.user.date}" pattern="yyyy-MM-dd"/>
<%--2019-05-08--%>
</body>
</html>

6.2 Map

@RequestMapping("data2")
//在方法形参上写上Map<String,Object> map
public String data2(Map<String,Object> map){
    User user = new User("cgp", 18, new Date(), new Address("浙江", "温州"));
    map.put("user",user);//map里面存放数据  就会往request域对象放
    return "index";//转发
}

页面显示代码同上

6.3 Model

将map替换成model即可!

@RequestMapping("data3")
public String data3(Model model){
    User user = new User("cgp", 18, new Date(), new Address("浙江", "温州"));
    model.addAttribute("user",user);
    return "index";
}

总结: 使用以上三种情况可以将数据返回给页面,页面使用EL表达式即可获取!但是要注意!数据放入的是requestScope域!其他域获取不到!

验证代码:

${name}
${requestScope.name}
${sessionScope.name}
----------------------------------------
结果显示值!前两个显示!sessionScope不显示!

如果需要在sessionScope复制一份!可以利用@SessionAttributes属性!

@SessionAttributes(names = "user")  //names可以选择多个值,但是必须是已有的命名!
@Controller
@RequestMapping("data")
public class DataController {...}

七、 控制器方法中使用原生API

如果我们需要使用Servlet内部常用类:

• HttpServletRequest
• HttpServletResponse
• HttpSession 等

直接在Controller层的方法中传入对应参数即可!不分顺序!

注意:如果使用maven项目 需要导入 jsp jstl servlet api

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2.1-b03</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

Java代码示例:

@Controller
@RequestMapping("servlet")
public class ServletApiController {
    @RequestMapping("api")
    public void test(HttpServletRequest request, HttpServletResponse response, HttpSession session) throws ServletException, IOException {
        User user = new User("cgp", 18, new Date(), new Address("浙江", "温州"));
        ServletContext context = request.getServletContext();
        request.setAttribute("user",user);
        session.setAttribute("user",user);
        context.setAttribute("user",user);
        System.out.println(session.getId());
        request.getRequestDispatcher("/WEB-INF/jsp/index.jsp").forward(request,response);
    }
}