{{π型人才培养计划}}Spring

Spring框架

引言

概念: 是轻量级的javaEE解决方案，众多优秀设计模式的组合

核心体系：

Spring工厂

​ 回顾：工厂设计模式

​ 作用：创建对象

​ 好处：解耦合[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接

开发流程：

​ 环境搭建

​ 1.引入相关依赖

<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.2.RELEASE</version>
</dependency>

​ 2.引入Spring的配置文件

​ 命名：随意 建议：applicationContext.xml

​ 放置位置：随意 建议：放置在根目录下

​ 3.相关API

​ ApplicationContext 接口

​ 实现类： ClassPathXMLApplicationContext

​ 特点： 重量级资源 内存占用大 只创建一次 功能多 线程安全

​ 开发步骤:

​ 1.创建类

​ 2.在Spring的配置文件中 配置该类的相关信息

​ 3.Spring工厂创建对象

​

spring工厂创建对象的原理

Spring注入

​ 概念： 在Spring工厂创建对象的同时，为该对象的属性赋值

​ 分类：

​ 1.Set注入

​ 原理：底层通过调用该属性的set方法做属性赋值

​ 前提：给该属性提供Set方法

​ 属性注入分类：

​ 1.JDK类型

​ i.8中基本数据类型+String

​ ii.数组

​ iii. List

​ iv. Set

​ v. Map

​ properties 特殊的Map 键为String 值 String

​

​ 2.自定义类型(自建类型)

​ 2.构造注入（了解）

​ 原理：调用类中的有参构造为属性做对应的注入

​ 前提：提供有参构造

​ 3.自动注入 autowire

​ 使用场景： 应用在自定义类型注入

​ autowire=“byName” 扫描Spring配置文件 通过所要注入的属性名进行匹配对应的类型 自动进行注入

​ autowire=“byType” 扫描Spring配置文件 匹配合适的类型 自动进行注入

IOC（Inversion of Control） 反转控制

​ 控制：给属性赋值的权利

​ 反转: 把给属性赋值的权利由代码反转到了配置文件中

DI（Dependency Injection） 依赖注入

​ 概念: 当一个类型，需要另一个类型时，就可以把另一个类型作为该类型属性，进行对应的注入

FactoryBean技术

​ 作用：创建复杂对象

​
​ 开发步骤：

​ 1.implements FactoryBean接口

package com.baizhi.factorybean;

import org.springframework.beans.factory.FactoryBean;

import java.sql.Connection;
import java.sql.DriverManager;

//创建的复杂对象的类型
public class ConnectionFactory  implements FactoryBean<Connection> {
    /*
     *
     * 书写创建复杂对象的步骤
     *
     * */
    @Override
    public Connection getObject() throws Exception {
        Class.forName("oracle.jdbc.OracleDriver");
        Connection connection = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:xe");
        return  connection;
    }

    /*
    *
    * 返回创建的复杂对象的类型
    *
    * */
    @Override
    public Class<?> getObjectType() {
        return  Connection.class;
    }

    /*
    *
    * 控制创建对象的次数
    * 返回值：
    *         false: 每一次都会创建新的对象
    *         true:  只会创建一次对象
    * */
    @Override
    public boolean isSingleton() {
        return false;
    }
}

​ 2.Spring配置文件配置该类的信息

控制简单对象创建的次数

       scope="singleton"  默认值   对象只创建一次
            ="prototype"           对象创建多次
            
       哪些对象只创建一次？
            ApplicationContext(Spring工厂)  SqlSessionFactory(创建一次)  DAO   Service  
       哪些对象需要创建多次？
            Connection   SqlSession    Action(struts2)  ShoppingCart  
            
            

Spring工厂创建对象的生命周期

        对象什么时候被创建？
               工厂被创建则对象被创建    （饿汉式创建）  提高效率
        对象什么时候被销毁？
               工厂关闭则对象销毁
        init-method属性：指定初始化（创建对象）时 调用的方法
        destory-method属性：对象销毁时，调用的方法

###             Spring工厂创建对象的生命周期

```java
        对象什么时候被创建？
               工厂被创建则对象被创建    （饿汉式创建）  提高效率
        对象什么时候被销毁？
               工厂关闭则对象销毁
        init-method属性：指定初始化（创建对象）时 调用的方法
        destory-method属性：对象销毁时，调用的方法

配置信息参数化

概念： 把Spring配置文件中经常需要修改的配置，抽取到小配置文件中

开发步骤：

​ 1.准备小配置文件 jdbc.properties

​ 2.读取小配置文件

​ 3.获取小配置文件中对应的值

BeanPostProcessor技术 后置处理bean

作用：解决对象再加工问题

SpringAOP编程

静态代理设计模式

​
​ 概念：

​ 原始类： 只负责核心功能的类

​ 原始方法：原始类中的方法

​ 代理类：给原始类添加额外功能的类

​ 代理的本质：代理只负责额外功能，通过代理类为原始类添加额外功能

​ 缺点：

​ 1.类过载

​ 2.额外功能代码冗余

动态代理设计模式

​ 1.引入Spring相关依赖

​ 2.开发步骤：

​ i. 书写原始类

​ ii.配置原始类的相关信息

​ iii. 书写额外功能类

​ implements MethodBeforeAdvice 前置通知

​ 作用： 额外功能会在原始方法执行之前执行

package com.baizhi.dynamicporxy;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class Before implements MethodBeforeAdvice {

    /*
    * 书写额外功能代码    该方法在原始方法之前执行
    * 方法作用:  在原始方法之前执行额外额外功能
    * 参数作用：
    *           method:  原始方法  的方法对象
    *           args:   给对应的原始方法 添加的实参
    *           target:  添加给的原始方法所在的类  创建的对象
    *
    *
    *
    *
    *
    *
    * */
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {
        //获取原始方法的名字
        System.out.println("方法名"+method.getName());
        //遍历
        for (Object arg : args) {
            System.out.println("参数"+arg);
        }
        System.out.println("类型"+target.getClass());
        System.out.println("------额外功能8888888---------");
    }
}

​ implements AfterReturningAdvice 后置通知

​ 作用：额外功能运行在原始方法之后执行

package com.baizhi.dynamicporxy;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class After  implements AfterReturningAdvice {
    /*
     * 方法作用: 运行在原始方法之后执行
     * 参数作用:
     *          ret  代表原始方法的返回值
     *          method: 原始方法的对象
     *          args: 原始方法传入的实际参数
     *          target: 原始方法所在的类 创建的对象
     * */
    @Override
    public void afterReturning(Object ret, Method method, Object[] args, Object  target) throws Throwable {
        System.out.println("返回值"+ret);
        System.out.println("方法名"+method.getName());
        for (Object arg : args) {
            System.out.println("传入的实参"+arg);
        }
        System.out.println(target.getClass());
        System.out.println("原始方法执行之后执行的额外功能");
    }
}

​ implements MethodInterceptor 环绕通知

​ 作用： 运行在原始方法之前后执行

package com.baizhi.dynamicporxy;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class Around  implements MethodInterceptor {

    /*
     *
     *  方法作用: 运行在原始方法之前后执行
     *
     * 参数作用：
     *     MethodInvocation  原始方法的封装
     *
     * 返回值：
     *     原始方法的返回值
     *
     * */

    @Override
    public Object invoke(MethodInvocation  mi) throws Throwable {
        System.out.println("原始方法执行之前执行");
        //原始方法的执行  ret代表原始方法的返回值
        Object ret = mi.proceed();
        System.out.println("原始方法执行之后执行");
        System.out.println("方法的返回值"+ret);
        return  ret;
    }
}

​ implements ThrowsAdvice接口 异常通知

​ 作用：产生异常时，执行对应的额外功能

package com.baizhi.dynamicporxy;

import org.springframework.aop.ThrowsAdvice;

public class MyThrows  implements ThrowsAdvice {
    //覆盖 afterThrowing  方法
    public  void   afterThrowing(Exception e){
        System.out.println("我是异常时 添加的额外功能");
    }
}

​ iv.配置额外功能类的相关信息

​ v.定义切入点

​ 作用：说明额外功能加入的具体位置

​ 1.方法切入点

​ 2.类切入点

​ 3.包切入点

​ 其他两个切入点函数：

​ args: 只专注于方法的参数 与类、包均无关

​ within: 只专注与类、包

​ 以注解为维度进行切入:

​ 自定义注解：

​

​

​ vi.组装切面

​ 作用: 指定把对应的额外功能加入到对应的切入点上

Spring动态代理原理

​ 问题：为什么通过原始类的ID获取到的是代理类的对象？

1.JDK实现动态代理 （基于接口）

​ ClassLoader: 类加载器

InterFaces：         获取与原始类相同的接口
InvocationHandler：  额外功能
//底层创建代理对象
Proxy.newProxyInstance(ClassLoader,InterFaces, InvocationHandler);

package com.baizhi.原理;

import org.junit.Test;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class TestJDK {

    @Test
    public   void   testJDK(){
        final UserService userService=new  UserServiceImpl();
        //获取到原始类实现的接口
        Class<?>[] interfaces = userService.getClass().getInterfaces();
        //创建额外功能
        InvocationHandler invocationHandler = new InvocationHandler() {
            //返回值 Object   原始方法的返回值
            @Override         //原始类对象       原始方法           原始方法的参数
            public Object invoke(Object target, Method method, Object[] args) throws Throwable {
                System.out.println("原始方法执行之前执行的功能");
                //调用原始方法  原始方法的返回值
                Object ret = method.invoke(userService, args);
                System.out.println("原始方法执行之后执行的功能");
                return ret;
            }
        };
        //创建动态代理对象             //借类加载器          //相同的接口    //额外功能
        UserService  proxy=(UserService) Proxy.newProxyInstance(TestJDK.class.getClassLoader(), interfaces, invocationHandler);
        proxy.register();
    }
}

2.CGLIB实现动态代理（基于父子类继承关系）

package com.baizhi.原理;

import org.junit.Test;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.InvocationHandler;

import java.lang.reflect.Method;

public class TestCGLIB {
    @Test
    public   void   testCglib(){
        //原始类对象
        final UserService userService= new  UserServiceImpl();
        //额外功能
        InvocationHandler invocationHandler = new InvocationHandler() {
            /*
             * 返回值 代表调用原始方法的返回值
             *
             * */
            @Override           //原始类对象  原始方法          调用原始方法的参数
            public Object invoke(Object o, Method method, Object[] args) throws Throwable {
                System.out.println("原始方法执行之前执行");
                //调用原始方法
                Object ret = method.invoke(userService, args);
                System.out.println("原始方法执行之后执行");
                return ret;
            }
        };
        //创建enhancer对象
        Enhancer enhancer = new Enhancer();
        //设置类加载器
        enhancer.setClassLoader(TestCGLIB.class.getClassLoader());
        //把原始类作为父类  保证原始类与代理类拥有相同的方法
        enhancer.setSuperclass(userService.getClass());
        //设置额外功能
        enhancer.setCallback(invocationHandler);
        //创建代理对象
        UserServiceImpl userService1 =(UserServiceImpl)enhancer.create();
        userService1.register();
    }
}

​ Spring默认的动态代理方式： JDK动态代理

​ proxy-target-class=“false” 默认值为false JDK动态代理

​ “true” 默认值为true CGLIB代理

SM整合（Spring+Mybatis）

​ 回顾mybatis开发步骤：

​ 1.建表

​ 2.写实体

​ 3.定义DAO接口

​ 4.Mapper文件实现DAO接口

​ 5.API测试

​ 开发流程：

​ 环境搭建：

​ 1.引入相关依赖

<dependency>
  <groupId>org.apache.logging.log4j</groupId>
  <artifactId>log4j-core</artifactId>
  <version>2.11.1</version>
</dependency>
<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-log4j12</artifactId>
  <version>1.7.5</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.2.8</version>
</dependency>

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.1</version>
</dependency>
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.40</version>
</dependency>
<dependency>
  <groupId>commons-dbcp</groupId>
  <artifactId>commons-dbcp</artifactId>
  <version>1.4</version>
</dependency>
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.12</version>
</dependency>
                                                   ```

​ 2.引入log4j.properties配置文件

​ 3.引入Spring的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--读取小配置文件 并获取其中的连接数据库参数-->
    <context:property-placeholder location="jdbc.properties"></context:property-placeholder>

    <!--配置数据源                     使用DBCP连接池     -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <!--连接数据库的相关参数-->
        <property name="driverClassName"  value="${driver}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${name}"></property>
        <property name="password" value="${password}"></property>
    </bean>

    <!--自动创建SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--构建SqlSessionFactory需要依赖数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!--起别名  该包下所有的类自动起别名  默认别名是该类的类名-->
        <property name="typeAliasesPackage">
            <value>com.baizhi.entity</value>
        </property>
        <!--Mapper文件注册-->
        <property name="mapperLocations">
            <list>   <!--给com/baizhi/dao包下的以Mapper.xml结尾的文件自动进行注册-->
                <value>com/baizhi/dao/*Mapper.xml</value>
            </list>
        </property>
    </bean>
    <!--自动构建DAO的实现类对象-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--告知Spring  给com.baizhi.dao包下的所有的接口构建DAO的实现类对象-->
        <property name="basePackage">
            <value>com.baizhi.dao</value>
        </property>
    </bean>
</beans>

​ 开发步骤：

​ 1.建表

​ 2.写实体

​ 3.定义DAO接口

​ 4.Mapper文件实现DAO接口

​ 5.配置Spring的配置文件

​ 6.API测试

​ 通过接口名称首字母小写获取实现类对象

Spring声明式事务

​ 注意：Spring提供小的事务 仅供测试使用

​ 回顾：

​ 1.事务是什么？

​ 保证一组DAO操作一起成功，一起失败

​ 2.事务应用在哪一层？

​ Service层

​ 3.如何控制事务？

​ JDBC：

​ connection.setAutoCommit(false);

​ connection.commit();

​ connection.rollback();

​ Mybatis:

​ sqlSession.commit();

​ sqlSession.rollback();

Spring事务开发步骤

​ 思路：把事务划分为额外功能，通过动态代理的开发步骤，把事务添加到对应的事务

​ 1书写原始类

​ 2.配置原始类的相关信息

​ 3.书写额外功能类

​ 4.定义切入点

​ 5.组装切面

Spring事务属性

​ 1.隔离属性 isolation

​ 脏读: 一个事务读取了另一个事务 尚未提交的数据

​ isolation=“READ_COMMITTED” 解决脏读问题 列锁

​ 重复读： 多次读取数据 读到的结果不一致

​ isolation=“REPEATABLE_READ” 不可重复读 行锁

​ 幻影读： 多次统计的结果不一致

​ isolation=“SERIALIZABLE” 解决幻影读 表锁

​ 安全性： SERIALIZABLE>REPEATABLE_READ>READ_COMMITTED

​ 效率： READ_COMMITTED>REPEATABLE_READ>SERIALIZABLE

​ 实战开发中：

​ isolation=“DEFAULT” 根据数据库的隔离属性而定

​ Oracle默认隔离级别：READ_COMMITTED

​ Mysql默认隔离级别： REPEATABLE_READ

​ 2.传播属性

​ 作用：事务嵌套问题

​ propagation=“REQUIRED” 外部有事务则融入外部事务中，外部没有事务，则开启新的事务 （增删改)

​ propagation=“SUPPORTS” 外部有事务则融入到外部事务中，外部没有事务，则不开启新的事务 (查询)

​ 3.只读属性

​ read-Only 默认值false (增删改)

​ read-Only 设置为true （查询)

​ 4.超时属性

​ time-out 默认值 -1 根据数据库的超时属性决定

​ 作用：设置具体等待时长

​ 5.异常属性

​ 默认：对RunTimeException 进行回滚操作

​ 对非RunTimeException 进行提交操作

​ rollback-for 指定哪些异常（含子类）进行回滚

​ no-rollback-for 指定哪些异常（含子类）进行提交

​ 总结：

​ 增删改： isolation=“DEFAULT” propagation=“REQUIRED” read-Only =false

​ time-out =-1 异常属性将来根据需求定

​ 查询： isolation=“DEFAULT” propagation=”SUPPORTS“ read-Only =true

​ time-out =-1 异常属性将来根据需求定

<?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: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="jdbc.properties"></context:property-placeholder>

    <!--配置数据源                     使用DBCP连接池     -->
    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
        <!--连接数据库的相关参数-->
        <property name="driverClassName"  value="${driver}"></property>
        <property name="url" value="${url}"></property>
        <property name="username" value="${name}"></property>
        <property name="password" value="${password}"></property>
    </bean>

    <!--自动创建SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--构建SqlSessionFactory需要依赖数据源 -->
        <property name="dataSource" ref="dataSource"></property>
        <!--起别名  该包下所有的类自动起别名  默认别名是该类的类名-->
        <property name="typeAliasesPackage">
            <value>com.baizhi.entity</value>
        </property>
        <!--Mapper文件注册-->
        <property name="mapperLocations">
            <list>   <!--给com/baizhi/dao包下的以Mapper.xml结尾的文件自动进行注册-->
                <value>com/baizhi/dao/*Mapper.xml</value>
            </list>
        </property>
    </bean>
    <!--自动构建DAO的实现类对象-->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--告知Spring  给com.baizhi.dao包下的所有的接口构建DAO的实现类对象-->
        <property name="basePackage">
            <value>com.baizhi.dao</value>
        </property>
    </bean>

    <!--配置UserServiceImpl的相关信息-->
    <bean id="userService" class="com.baizhi.service.UserServiceImpl">
            <!--属性-->          <!--自动创建好的实现类对象的ID-->
        <property name="userDAO" ref="userDAO"  ></property>
    </bean>

    <!--引入事务额外功能代码-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
         <!--控制事务需要连接  连接需要连接数据库的相关参数  -->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--描述事务对应的属性-->
    <tx:advice id="dstm" transaction-manager="transactionManager">
        <tx:attributes>
            <!--对register方法上的事务做对应的描述-->
            <tx:method name="modify*"/>
            <!--除了以modify开头的方法以外采用对应的属性值-->
            <tx:method name="*" propagation="SUPPORTS" read-only="true"/>
        </tx:attributes>
    </tx:advice>
    <!--定义切入点-->
     <aop:config>
         <!--给com.baizhi.service包下以及子包下的所有方法添加-->
         <aop:pointcut id="pc" expression="execution(* com.baizhi.service..*.*(..))"></aop:pointcut>
         <aop:advisor advice-ref="dstm" pointcut-ref="pc"></aop:advisor>
     </aop:config>
</beans>

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>servlet-api</artifactId>
  <version>2.5</version>
  <scope>provided</scope>
</dependency>

<!-- 引入spring相关的jar -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>

<!-- 引入mybatis相关jar -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.2.8</version>
</dependency>

<!-- 引入mybatis 与 spring 整合jar -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.2</version>
</dependency>

<!-- 引入struts2 -->
<dependency>
  <groupId>org.apache.struts</groupId>
  <artifactId>struts2-core</artifactId>
  <version>2.3.16</version>
</dependency>

<!--  引入struts2 与spring的整合jar -->
<dependency>
  <groupId>org.apache.struts</groupId>
  <artifactId>struts2-spring-plugin</artifactId>
  <version>2.3.16</version>
</dependency>

<!-- 引入mysql -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>

<!-- 引入dbcp -->
<dependency>
  <groupId>commons-dbcp</groupId>
  <artifactId>commons-dbcp</artifactId>
  <version>1.4</version>
</dependency>

<!-- 引入fastjson -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.47</version>
</dependency>


<!-- 引入log4j -->
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.15</version>
</dependency>

<!--引入jstl标签-->
<dependency>
  <groupId>jstl</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>

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

​

javax.servlet
servlet-api
2.5
provided

<!-- 引入spring相关的jar -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-core</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aspects</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-tx</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-jdbc</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-web</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-beans</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-expression</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>4.3.2.RELEASE</version>
</dependency>

<!-- 引入mybatis相关jar -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis</artifactId>
  <version>3.2.8</version>
</dependency>

<!-- 引入mybatis 与 spring 整合jar -->
<dependency>
  <groupId>org.mybatis</groupId>
  <artifactId>mybatis-spring</artifactId>
  <version>1.3.2</version>
</dependency>

<!-- 引入struts2 -->
<dependency>
  <groupId>org.apache.struts</groupId>
  <artifactId>struts2-core</artifactId>
  <version>2.3.16</version>
</dependency>

<!--  引入struts2 与spring的整合jar -->
<dependency>
  <groupId>org.apache.struts</groupId>
  <artifactId>struts2-spring-plugin</artifactId>
  <version>2.3.16</version>
</dependency>

<!-- 引入mysql -->
<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.38</version>
</dependency>

<!-- 引入dbcp -->
<dependency>
  <groupId>commons-dbcp</groupId>
  <artifactId>commons-dbcp</artifactId>
  <version>1.4</version>
</dependency>

<!-- 引入fastjson -->
<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.47</version>
</dependency>


<!-- 引入log4j -->
<dependency>
  <groupId>log4j</groupId>
  <artifactId>log4j</artifactId>
  <version>1.2.15</version>
</dependency>

<!--引入jstl标签-->
<dependency>
  <groupId>jstl</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>

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

SS整合(Spring+Struts2)

​ 环境搭建：

​ 1.引入相关依赖

<dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>
    <!-- 引入javaEE规范 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

    <!-- 引入spring相关的jar -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <!-- 引入struts2 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>2.3.16</version>
    </dependency>

    <!--  引入struts2 与spring的整合jar -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-spring-plugin</artifactId>
      <version>2.3.16</version>
    </dependency>

    <!-- 引入mysql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>


    <!-- 引入log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.15</version>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.5</version>
    </dependency>

​ 2.初始化配置 web.xml

Struts2核心过滤器

 <!--配置Struts2的核心过滤器-->
     <filter>
       <filter-name>struts2</filter-name>
       <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
     </filter>

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

Spring的工厂监听器

​ 作用:在web开发中，创建Spring的工厂

​ 开发步骤：

​ 1.定义Service接口

​ 2.实现Service接口

​ 3.配置Service的相关信息

​ 4.开发Action

​ 5.配置Action的相关信息

​
​ 6.配置Struts.xml

SSM整合（配置文件版）

​ 整合思路：

​ 环境搭建：

​ 1.引入相关依赖

 <!-- 引入javaEE规范 -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.5</version>
      <scope>provided</scope>
    </dependency>

    <!-- 引入spring相关的jar -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-core</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-web</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-beans</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-expression</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

    <!-- 引入mybatis相关jar -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.2.8</version>
    </dependency>

    <!-- 引入mybatis 与 spring 整合jar -->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>1.3.2</version>
    </dependency>

    <!-- 引入struts2 -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-core</artifactId>
      <version>2.3.16</version>
    </dependency>

    <!--  引入struts2 与spring的整合jar -->
    <dependency>
      <groupId>org.apache.struts</groupId>
      <artifactId>struts2-spring-plugin</artifactId>
      <version>2.3.16</version>
    </dependency>

    <!-- 引入mysql -->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.38</version>
    </dependency>

    <!-- 引入dbcp -->
    <dependency>
      <groupId>commons-dbcp</groupId>
      <artifactId>commons-dbcp</artifactId>
      <version>1.4</version>
    </dependency>

    <!-- 引入fastjson -->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.47</version>
    </dependency>


    <!-- 引入log4j -->
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.15</version>
    </dependency>

    <!--引入jstl标签-->
    <dependency>
      <groupId>jstl</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>

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

​ 2.初始化配置 web.xml

​ Struts2的核心过滤器

​ Spring的工厂监听器

<web-app>
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
  </context-param>

   <!--Struts2的核心过滤器-->
  <filter>
    <filter-name>struts2</filter-name>
    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
  </filter>
  <filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>
  </filter-mapping>
  
  <!--Spring的工厂监听器-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

​ 开发步骤:

​ 1.建表

​ 2.写实体

​ 3.定义DAO接口

​ 4.Mapper文件实现DAO接口

​ 5.在Spring配置文件中配置mybatis的相关内容

​ 6.定义Service接口

​ 7.实现Service接口

​ 8.配置Service的相关信息

​ 9.配置额外功能事务

   <!--引入关于事务的核心代码-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!--关于事务的描述属性-->
    <tx:advice id="dstm" transaction-manager="transactionManager">
         <tx:attributes>
             <tx:method name="modify*"/>
             <tx:method name="*" propagation="SUPPORTS" read-only="true"></tx:method>
         </tx:attributes>
    </tx:advice>


    <aop:config>
        <!--定义切入点-->
        <aop:pointcut id="pc" expression="execution(*  com.baizhi.service..*.*(..))"></aop:pointcut>
        <!--组装切面-->
        <aop:advisor advice-ref="dstm" pointcut-ref="pc"></aop:advisor>
    </aop:config>

​ 10.开发Action

​ 11.配置Action的相关信息

<!--配置Action的相关信息-->
<bean id="userAction" class="com.baizhi.action.UserAction" scope="prototype">
     <!--Service的注入-->
     <property name="userService" ref="userService"></property>
</bean>

​ 12.配置Struts的相关信息

 <package name="user" extends="struts-default" namespace="/user">
        <action name="register" class="userAction" method="register">
             <result name="index">
                 /index.jsp
             </result>
        </action>
    </package>                       

SSM整合(注解版)

​ 作用: 替换配置文件中繁琐的配置 提高开发效率

​ 使用：

​ 1.把对应注解放置在对应的位置上

​ 2.告知Spring框架在哪一个位置使用了注解

​ 常用注解：

​ 1.@Component 创建简单对象

​ 位置：类的上边

​ 注意：默认提供的ID 是该类类名首字母小写

​ 2.@Autowired 给属性进行自动注入

​ 前提：Spring工厂中已经拥有该实现类对象

​ 3.@Service 创建Service的实现类对象

​ 4.@Transactional 给对应的方法添加事务

​ 前提：激活@Transactional 注解

​ 5.@Controller 自动创建Action的对象

​ 默认ID类名首字母小写

​ 6.@Scope 指定创建对象的次数

​ SSM(注解版)开发步骤

​ 环境搭建：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
  
  
     <!--Struts2的核心过滤器-->
      <filter>
        <filter-name>struts2</filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
      </filter>
       <filter-mapping>
         <filter-name>struts2</filter-name>
         <url-pattern>/*</url-pattern>
       </filter-mapping>
  
    <!--配置Spring工厂的监听-->
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
</web-app>

​ 步骤：

​ 1.建表

​ 2.写实体

​ 3.定义DAO接口

​ 4.Mapper文件实现DAO接口

​ 5.在Spring配置文件中配置mybatis的相关内容

​ 6.定义Service接口

​ 7.实现Service接口

​ @Service

​ @Autowire

​ 8.为Service添加声明式事务

​ 9.开发Action

​ @Controller

​ @Scope

​ @Autowire

​ 10.配置Action的相关信息

​ 11.告知Spring框架 扫描对应的注解

补充：

​ Spring注解与Junit集成

1.引入对应依赖

 <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>4.3.2.RELEASE</version>
    </dependency>

2.使用

package com.baizhi.test;


import com.baizhi.dao.UserDAO;
import com.baizhi.entity.User;
import com.baizhi.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

//集成注解
@RunWith(SpringJUnit4ClassRunner.class)
//自动构建Spring工厂 相当于    //创建Spring的工厂
//        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
@ContextConfiguration("classpath:applicationContext.xml")
public class TestAnonationDriven {

    @Autowired
    private UserDAO userDAO;

    @Autowired
    private UserService userService;

    @Test
    public  void   test1(){
        List<User> users = userDAO.selectAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
    @Test
    public  void   test2(){
        userService.register(new User("111","瞎说说","123",18));

    }
}

​ Druid连接池的使用

1.引入druid对应的依赖

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

2.配置