spring总结


阅读数: 次   

spring

Spring是一个轻量级控制反转(IoC)和面向切面(AOP)的容器框架。主要应用于service层

1. J2EE三层架构

在这里插入图片描述

  1. 表现层（spring-mvc）
    主要是JSP和HTML页面，用于接收du用户的zhi请求，以及返dao回操作数据，是应用专程序访问的入属口。
  2. 业务逻辑层service（spring）
    主要是对数据层进行操作，对数据逻辑层进行处理，如果数据层是积木，那么逻辑层就是堆积木的搭建。
  3. 数据访问层dao（mybatis）
    主要是对原始数据的操作层，具体为业务逻辑层或表现层提供数据服务。

    2. ioc(xml实现)

    控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

正转：用new来创建对象。
ioc可以减少对代码的改动。

2.1. 构造对象的方法

  • 使用new来创建对象
  • 使用反射创建对象
  • 序列化
  • 克隆
  • ioc：使用容器创建对象

2.2. ioc在javaweb中的体现

servlet：在使用servlet时，没有主动创建对象，而是容器Tomcat帮你创建好servlet对象

1
2
3
4
5
6
7
8
9
<!--使用xml注册servlet-->
    <servlet>
        <servlet-name>RegisterServlet</servlet-name>
        <servlet-class>com.hjznb.controller.RegisterServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>RegisterServlet</servlet-name>
        <url-pattern>/reg</url-pattern>
    </servlet-mapping>

在使用的时候我们可以直接使用servlet，而不用使用
Servlet s = new Servlet();来创建对象，这些对象都被Tomcat创建好。

2.3. DI依赖注入

DI是ioc技术的实现，只需要在程序中提供要使用的对象的名称就可以，至于对象如何在容器中创建、赋值、查找都是容器内部实现

spring使用di实现了ioc的功能，spring底层创建对象，使用的是反射机制。

spring是一个容器，管理对象，给属性赋值，底层是反射创建对象。

2.4. 使用spring创建对象(使用xml)

1.首先创建一个maven项目，在pom文件中加入spring的依赖，并修改jdk版本

1
2
3
4
5
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.2.5.RELEASE</version>
</dependency>
1
2
3
4
5
<properties>
  <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  <maven.compiler.source>11</maven.compiler.source>
  <maven.compiler.target>11</maven.compiler.target>
</properties>

2.创建接口和实现类

1
2
3
public interface SomeService {
    public void doSome();
}
1
2
3
4
5
6
public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome() {
        System.out.println("执行了dosome方法");
    }
}

3.在main文件下创建resource目录，在里面创建spring配置xml文件，声明bean标签，一个bean标签即为一个对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        告诉spring创建对象
        声明bean，就是告诉spring要创建某个类的对象
        id：对象的自定义名称，唯一值，spring通过这个名称找到对象
        class：类的全限定名称（不能是接口，因为spring使用反射创建对象）

        spring完成了 SomeService someService = new SomeServiceImpl();
        spring将创建好的对象放入map中，spring框架有一个map存放对象
            springMap.put(id,对象);
            springMap.put("someService",new SomeServiceImpl());

        一个bean标签声明一个对象
    -->
    <bean id="someService" class="com.hjznb.service.impl.SomeServiceImpl" />
    <bean id="someService1" class="com.hjznb.service.impl.SomeServiceImpl"/>
</beans>
<!--
    spring配置文件
    beans：根标签，spring将java对象称作bean
    spring-beans.xsd：spring约束文件
    -->

4.在程序中创建容器对象ApplicationContext，使用bean标签的id来获取容器中创建好的对象。创建对象的时间为创建ApplicationContext的时候。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
 * spring构造对象默认调用无参构造方法
 */
@Test
public void test(){
    //指定spring配置文件的名称
    String config = "beans.xml";

    //创建表示spring容器的对象ApplicationContext,是一个接口
    //ClassPathXmlApplicationContext：表示从类路径中加载spring配置文件
    //类路径为target.classes包，需要将配置文件复制到该包中
    //此时会创建配置文件中的所有对象
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);

    //从容器中获取某个对象getBean
    SomeService ss = (SomeService) ac.getBean("someService");
    ss.doSome();
}

注意：spring不止能够创建自定义对象，也能够创建那些已存在的对象，只要class属性给出类的路径

2.5. 获取ApplicationContext容器中的信息

ApplicationContext对象中有许多方法，可以获取容器中对象的信息

1
2
3
4
5
6
7
8
9
//获取容器中创建的对象的数目
int num = ac.getBeanDefinitionCount();
System.out.println("容器中的对象数目为:"+num);//2

//获取容器中定义的对象的名称
String[] names = ac.getBeanDefinitionNames();
for(String n:names){
    System.out.println(n);
}//id值

2.6. 设值注入

spring调用类的set方法，在set方法可以实现属性的赋值，因此需要要创建的类中必须有set方法

在bean标签中使用property标签来注入值，set注入会在指定类中寻找set方法，使用set方法将value属性赋给方法参数来给属性赋值。

寻找的格式是set+name属性的首字母大写，所以即使类中没有对应的属性，只要有格式setName(value) 的方法存在，就可以使用set注入。

1
2
3
4
5
<bean id="student" class="com.hjznb.ba01.Student">
    <property name="age" value="18"/><!--即使是int类型也要加引号-->
    <property name="name" value="海拔狗"/>
    <property name="no" value="123456"/><!--spring看见name中的内容，会去调用setNo方法，即使没有no属性-->
</bean>

Student类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class Student {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("调用了setName方法："+name);
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        System.out.println("调用了setAge方法："+age);
        this.age = age;
    }
	//该方法并不是给属性赋值的方法，但仍然可以使用set注入
    public void setNo(String no){
        System.out.println("No = "+no);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

注意：设置注入只是使用set方法！

引用类型的设置注入不是使用value，而是使用ref属性来指定注入的类，被注入的类要在容器中先被创建好。

下面将Student类中添加一个School属性，使用set注入给其设值

School类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class School {
    private String address;
    private String name;

    public void setAddress(String address) {
        this.address = address;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "School{" +
                "address='" + address + '\'' +
                ", name='" + name + '\'' +
                '}';
    }
}

在Student类中添加School属性和对应的set方法

1
2
3
4
5
6
7
8
9
10
11
public class Student {
    private String name;
    private int age;
    private School school;

    public void setSchool(School school) {
        this.school = school;
    }
    ...
    
}

然后在配置文件中先配置好School的bean，先创建好School类的对象，再将其注入到Student类中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        引用类型的set注入，name为属性名，ref为bean的id
    -->
    <bean id="student" class="com.hjznb.ba02.Student">
        <property name="age" value="20"/>
        <property name="name" value="y巴沟"/>
        <property name="school" ref="mySchool"/><!--ref为bean的id-->
    </bean>

    <bean id="mySchool" class="com.hjznb.ba02.School">
        <property name="name" value="坑大"/>
        <property name="address" value="西安"/>
    </bean>
</beans>

2.7. 构造注入

spring容器生成对象默认调用无参构造方法，如果需要使用有参构造方法来构造对象，需要使用构造注入。

构造注入可以使用参数名和下标来指定注入的值，使用
constructor-arg标签注入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<!--
    构造注入,调用有参构造方法
       public Student(String name, int age, School school)
-->
<!--使用name属性-->
<bean id="student" class="com.hjznb.ba02.Student">
    <constructor-arg name="age" value="20"/>
    <constructor-arg name="name" value="zhangsan"/>
    <constructor-arg name="school" ref="mySchool"/>
</bean>

<!--使用index属性,下标从左往右参数从0开始,index属性可以省略，默认从上到下从0开始赋值-->
<bean id="student1" class="com.hjznb.ba02.Student">
    <constructor-arg index="0" value="zhangsang"/>
    <constructor-arg index="1" value="21"/>
    <constructor-arg index="2" ref="mySchool"/>
</bean>

<bean id="mySchool" class="com.hjznb.ba02.School">
    <property name="name" value="坑大"/>
    <property name="address" value="西安"/>
</bean>

2.8. 自动注入

引用类型自动注入有两种方式：byName和byType
使用bean标签中的autowire属性来设置注入方式。

2.8.1. byName

byName是通过id名来进行注入的，如果属性名和bean标签id的一致，spring就会将对应的bean对象注入。

1
2
3
4
5
6
7
8
9
<bean id="myStudent" class="com.hjznb.ba03.Student" autowire="byName">
    <property name="name" value="张三"/>
    <property name="age" value="15"/>
</bean>

<bean id="school" class="com.hjznb.ba03.School">
    <property name="name" value="西坑大"/>
    <property name="address" value="西安"/>
</bean>

在这里，Student类中有一个School引用类型的属性school，通过byName自动注入方式，spring会在容器中寻找id名为school的对象，然后将其注入到bean中。

spring会对类中的每个引用类型都进行注入。

2.8.2. byType

byType是按类型注入，spring会扫描容器中的类，如果引用类型的数据类型和bean标签中的class属性中是同源关系的，spring会进行注入

同源关系指：

  • 引用类型的数据类型和class属性一致
  • 引用类型的数据类型和class属性为父子关系
  • 引用类型的数据类型和class属性为接口和实现类关系

autowire属性值为byType

1
2
3
4
5
6
7
8
9
10
11
12
<!--byType按类型注入引用类型-->
<!--查找类型同源的bean注入(实现类，子类，相等的类),并且只能有一个满足要求的bean-->
<bean id="myStudent" class="com.hjznb.ba03.Student" autowire="byType">
    <property name="name" value="张三"/>
    <property name="age" value="15"/>
    <!--byType是看bean标签中的class属性中的内容-->
</bean>

<bean id="pSchool" class="com.hjznb.ba03.PrimarySchool">
    <property name="name" value="小学"/>
    <property name="address" value="西安"/>
</bean>

PrimarySchool为School类型的子类，spring会将其创建对象赋给Student类的School属性

下面来测试是否将其注入

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class MyTest3 {
    @Test
    public void test(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("ba04/applicationContext.xml");
        com.hjznb.ba03.Student myStudent = (com.hjznb.ba03.Student) ac.getBean("myStudent");
        System.out.println(myStudent);
    }
}
//结果为
/*
默认构造方法
调用了setName方法：张三
调用了setAge方法：15
Student{name='张三', age=15, school=School{address='西安', name='小学'}}
*/

注意：使用byType自动注入时，只能有一个同源类型的类满足要求，如果有多个类满足注入的要求，spring会报错。

3. 使用多配置文件

使用多配置文件可以将功能不同的类（或不同模块中的类）放在不同的配置文件之中。

例如在这里有两个类：Student类和School类。我将他们放在两个不同的配置文件中创建bean，然后使用一个总配置文件将他们包含进来。

1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--school-->
    <bean id="pSchool" class="com.hjznb.ba05.PrimarySchool">
        <property name="name" value="小学"/>
        <property name="address" value="西安"/>
    </bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--student-->
    <bean id="myStudent" class="com.hjznb.ba05.Student" autowire="byType">
        <property name="name" value="张三"/>
        <property name="age" value="15"/>
    </bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        多配置文件：将功能不同的类（或不同模块中的类）放在不同的配置文件之中
        total为主配置文件：包含其他配置文件，主配置文件一般不自定义对象
        【重要】关键字classpath表示类路径(class文件夹所在的目录)
    -->

    <!--
    加载的是文件列表
    -->
    <import resource="classpath:ba05/spring-school.xml"/>
    <import resource="classpath:ba05/spring-student.xml"/>
</beans>

需要在总配置文件中使用import标签将其他配置文件包含进来，在配置文件中指定文件位置需要使用classpath。

也可以在指定路径时使用通配符*

1
<import resource="classpath:ba05/spring-*.xml"/>

它会寻找以spring-开头的文件

在使用时只需加载总配置文件就可以了

1
2
3
4
5
6
7
8
9
10
public class MyTest4 {
    @Test
    public void test(){
        //配置文件为主配置文件
        String config = "ba05/total.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Student student = (Student) ac.getBean("myStudent");
        System.out.println(student);
    }
}

即使两个bean在不同的配置文件中，仍然可以进行自动注入。

使用的时候尽量使用多配置文件，效率更高，避免冲突

4. ioc的注解实现

spring能用注解实现ioc，代替xml

4.1. 注解使用步骤

先加入依赖

1.首先在resource目录下创建spring的配置文件，在配置文件中声明组件扫描器,在扫描器中指定要扫描的包

1
2
3
4
5
6
<!--声明组建扫描器，组件就是java对象
    base-package：指定注解在你的项目中的包名
    会遍历base-package指定的包，找到类中的注解，创建对象
    -->
<context:component-scan base-package="com.hjznb.ba01"/>
<!--也能使用通配符‘*’-->

2.创建类，在需要spring创建对象的类上方添加对应的注解，@Component注解和bean标签的功能类似，括号中的value属性对应bean标签的id

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//@Component(value = "myStudent")
@Component("myStudent")//可以省略value
public class Student {
    private String name;
    private Integer age;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3.在测试类中创建容器对象，使用容器通过注解中的属性获取指定的对象

1
2
3
4
5
6
7
8
9
public class MyTest1 {
    @Test
    public void test1() {
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        Student student = (Student) ac.getBean("myStudent");
        System.out.println("student=" + student);
    }
}

4.2. 注解实现简单类型属性赋值

使用@Value(“属性值”)给属性赋值，位置可以在set方法的上方或者对应的属性上方

1
2
3
4
@Value("张三")
private String name;
@Value("20")
private Integer age;

如果在set方法的上方，其会传给方法参数

4.3. 注解实现引用类型赋值

@Autowired(required = true)注解给引用类型赋值，默认为byType自动注入，括号中的属性值是一个boolean类型的，表示当赋值失败后的操作，如果为true，则会报错；如果为false，会给引用类型赋值为null，默认为true

1
2
@Autowired(required = true)
private School school;

如果要使用byName来进行自动注入，就要使用@Qualifier(“属性”)标签，其中属性值为bean的id值，也就是注解中的value属性

该标签要和@Autowired注解一起使用。

1
2
3
@Autowired(required = true)
@Qualifier("mySchool")
private School school;

该注解的位置可以在属性上方或set方法上方

4.4. 常用注解

  • @Component：创建对象
  • @Repository，创建dao对象，用来访问数据库
  • @Service，创建Service对象，处理业务逻辑，可以有事务功能
  • @Controller，创建控制器对象，接受请求，处理结果
  • @Value简单类型的属性赋值
  • @Autowired：srping框架中的引用类型的赋值注解，支持byType和byName，默认为byType
  • @Resource：jdk中的注解，使用自动注入，默认为byName

其中@Resource(name =” id”)注解需要额外加入依赖

1
2
3
4
5
6
<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>

使用注解创建的对象也在容器中，所以注解能和xml一起使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <context:component-scan base-package="com.hjznb.ba03"/>
    
    <!--在使用注解的同时也能使用bean标签来创建对象-->
    <bean id="newStudent" class="com.hjznb.ba03.Student" autowire="byType">
        <property name="name" value="李四"/>
        <property name="age" value="15"/>
    </bean>
</beans>

5. aop

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

5.1. 使用jdk动态代理实现aop

如果我要给业务方法增加一个提交事务和打印日志的功能，并且不改变源代码，那么可以使用jdk的动态代理

要使用动态代理，首先要实现InvocationHandler类，在这个类的invoke方法中给目标方法增加功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class MyInvocationHandler implements InvocationHandler {
    //目标对象
    private Object target;//SomeServiceImpl类

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
        //        //通过代理对象执行方法时，会调用执行这个invoke
        System.out.println("执行InvocationHandler中的invoke方法");
        System.out.println("method:" + method.getName());
        Object res = null;
        //只在doSome方法中添加额外的功能
        if (method.getName().equals("doSome")) {
            //在SomeServiceImpl类中添加功能doLog，无须改动原类中的代码
            ServiceTools.doLog();
            //执行目标类的方法，通过Method类实现
            res = method.invoke(target, objects);
            //在SomeServiceImpl类中添加功能doTrans
            ServiceTools.doTras();
        } else {
            res = method.invoke(target, objects);
        }
        return res;
    }
}

里面使用的工具类

1
2
3
4
5
6
7
8
9
public class ServiceTools {
    public static void doLog(){
        System.out.println("打印日志"+new Date());
    }

    public static void doTras(){
        System.out.println("提交事务");
    }
}

创建InvocationHandler对象，使用该对象来代理目标类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class App
{
    public static void main( String[] args )
    {
        //使用jdk中的动态代理创建对象
        //创建目标对象
        SomeService target = new SomeServiceImpl();
        //创建InvocationHandler对象
        InvocationHandler handler = new MyInvocationHandler(target);
        //使用Proxy创建代理
        SomeService proxyInstance = (SomeService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),
                handler);
        //通过代理执行方法，会调用handler中的invoke()
        proxyInstance.doSome();
        System.out.println("===================================");
        proxyInstance.doOther();
    }
}

class com.sun.proxy.$Proxy0，可见得到的目标类的对象为代理对象，并且在没有修改目标类的代码的情况下增加了功能。

5.2. aspectj来实现aop

aspectj为一个框架，用来实现aop，spring框架中集成了aspectj框架，通过使用spring就能使用aspectj的功能，其实现aop有两种方式：

  • 使用xml配置文件：配置全局事务
  • 使用注解，在我们项目中要做aop功能，一般都使用注解，aspectj有五个注解

5.2.1. 使用aspectj的步骤

  1. 加入aspectj的依赖
1
2
3
4
5
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.5</version>
</dependency>
  1. 创建目标类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public interface SomeService {
    void doSome(String name,Integer age);

    String doOther(String name,Integer age);
}

public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name,Integer age) {
        System.out.println("========doSome方法==========");
    }

    @Override
    public String doOther(String name, Integer age) {
        System.out.println("========doOther方法==========");
        return "abcd";
    }
}
  1. 创建切面类，在类上边加入@Aspect注解，代表是切面类
1
2
3
4
@Aspect
public class MyAspect {
	...
}
  1. 在切面类中写要插入的方法，用通知注解和切入点表达式execution指明要插入的时间和位置
1
2
3
4
5
6
7
8
9
/*要插入的方法*/
    @Before(value = "execution(public void com.hjznb.ba01.SomeServiceImpl.doSome(String,Integer))")
    public void myBefore(JoinPoint jp){
        System.out.println("方法的签名："+jp.getSignature());
        System.out.println("方法的名称："+jp.getSignature().getName());
        System.out.println("方法的实参："+ Arrays.toString(jp.getArgs()));
        //就是你切面要执行的功能代码
        System.out.println("切面功能：在目标方法之前打印时间："+new Date());
    }
  1. 在容器中声明目标类和切面类的对象的bean（此处使用xml）
1
2
3
4
5
<!--目标类-->
<bean id="someService" class="com.hjznb.ba01.SomeServiceImpl"></bean>

<!--切面类-->
<bean id="myAspect" class="com.hjznb.ba01.MyAspect"/>
  1. 声明自动代理生成器
1
2
3
4
5
6
7
8
9
10
11
<!--
    声明自动代理生成器:使用aspectj框架内部的功能，创建目标对象的代理对象
    该标签会把spring容器中的所有目标对象，一次性都生成代理对象

    首先扫描配置文件中的类，寻找有@Aspect注解的类，然后寻找其中的方法，通过@Before和execution找到插入时间和位置
    生成目标对象的代理

    如果目标类有接口，就使用jdk动态代理com.sun.proxy.$Proxy16
    如果目标类无接口，就使用cglib代理
-->
<aop:aspectj-autoproxy/>
  1. 在测试代码中创建的目标类即使其的代理类
1
2
3
4
5
6
7
8
9
10
public class MyTest1 {
    @Test
    public void test1(){
        String config = "applicationContext.xml";
        ApplicationContext ac = new ClassPathXmlApplicationContext(config);
        //是其代理类
        SomeService ss = (SomeService) ac.getBean("someService");
        ss.doSome("132",20);
    }
}

5.2.2. aspectj的五个通知注解

通知注解表示切面的执行时间

  • @Before：前置通知注解。特点：

    •    1.在目标方法之前执行

    •    2.不会改变目标方法的执行结果

    •    3.不会影响目标方法的执行

  • @AfterReturning：后置通知。特点：

    •  1.在目标方法之后执行

    •  2.能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能

    •  Object res = doOther();

    •  3.可以修改这个返回值

  • @Around :环绕通知。 特点：

    •  1.它是功能最强的通知

    •  2.在目标方法的前和后都能增强功能

    •  3.控制目标方法是否被调用执行

    •  4.修改原来的目标方法的执行结果，影响最后的结果

    •  等同于jdk的动态代理

    •  环绕通知还能决定目标方法是否执行！！！！

  • @AfterThrowing 异常通知。特点：

    •     1.在目标方法抛出异常时执行

    •     2.可以做异常的监控程序，检测目标方法执行时是否有异常

  • @After 最终通知。特点：

    •     1.总是会执行

    •     2.在目标方法之后执行

      5.2.3. 切入点表达式

      每个通知注解内都有一个value属性，值为切入点表达式，决定该方法插入的位置。

语法：修饰符.返回值.包名.类名.方法(参数类型)

execution(public void com.hjznb.ba01.SomeServiceImpl.doSome(String,Integer))

可以使用通配符’*’和’..’，前者代表任意字符，后者代表任意层包。下面这个表达式表示插入位置为任意修饰符，任意包下的SomeServiceImpl类中的以doOther开头的方法，并且方法中的参数是任意

execution(* ..SomeServiceImpl.doOther(..)

5.2.4. 通知中的参数JoinPoint

指定通知方法中的参数：JoinPoint，可以查看方法的信息，必须放在第一个参数位置
* JoinPoint：业务方法，要加入切面功能的业务方法
* 作用是：可以在通知方法中获取方法执行时的信息，例如方法名称、实参等
* 如果你的切面功能中需要用到方法的信息，就加入JoinPoint
* 这个JoinPoint参数的值由框架赋予，必须是第一个位置的参数

5.2.5. 前置通知

使用前置通知和JoinPoint在方法执行前加入新功能。

  • 该方法无返回值
  • 可以有一个参数JoinPoint
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Before(value = "execution(public void com.hjznb.ba01.SomeServiceImpl.doSome(String,Integer))")
/*
*指定通知方法中的参数：JoinPoint
* JoinPoint：业务方法，要加入切面功能的业务方法
*   作用是：可以在通知方法中获取方法执行时的信息，例如方法名称、实参灯
*   如果你的切面功能中需要用到方法的信息，就加入JoinPoint
*   这个JoinPoint参数的值由框架赋予，必须是第一个位置的参数
* */
public void myBefore(JoinPoint jp){
    System.out.println("方法的签名："+jp.getSignature());
    System.out.println("方法的名称："+jp.getSignature().getName());
    System.out.println("方法的实参："+ Arrays.toString(jp.getArgs()));
    //就是你切面要执行的功能代码
    System.out.println("切面功能：在目标方法之前打印时间："+new Date());
}

5.2.6. 后置通知

使用后置通知查看目标方法返回值，但是不能修改。returning属性值和第切面方法第二个参数的名字一样，切面方法中的第二个参数即为返回值。

  • 该方法无返回值
  • 有一个Object类型的参数，即为目标方法的返回值
  • 不能修改返回值
1
2
3
4
5
6
7
8
@AfterReturning(value = "execution(* *..SomeServiceImpl.doOther*(..))",
                returning = "res")
public void myAfterReturning(JoinPoint jp,Object res){
    System.out.println(jp.getSignature());
    //Object res:是目标方法执行后的返回值
    System.out.println("后置通知：在目标方法之后执行的，返回值:"+res);
    res = "123";//不会变
}

5.2.7. 环绕通知

该通知为最强的通知，可以在目标方法之前或之后添加功能，还可以修改目标方法的返回值，并且能够控制目标方法是否被调用，是否被执行！

  • 该方法只有个固定的参数ProceedingJoinPoint ，该参数能够获取目标方法的参数或执行等等
  • 必须要有一个返回值！(推荐Object)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@Around(value = "execution(* *..SomeServiceImpl.doFirst(..))")
    public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
        //实现环绕通知
        Object result = null;
        System.out.println("环绕通知：显示时间="+ new Date());
        //获取方法参数
        Object[] args = pjp.getArgs();
        //可以使目标方法不执行
        if(args!=null&&args.length>1) {
            Object arg = args[0];
            if(arg.equals("张三")) {
                //目标方法调用
                result = pjp.proceed();
            }
        }
        //在目标方法的前和后添加功能
        System.out.println("环绕通知：提交事务");
        //环绕通知还能修改目标方法的返回结果
        result = "noway!";
        return result;
    }

5.2.8. 异常通知

异常通知方法的定义格式：

  • public
  • 没有返回值
  • 方法名称自定义
  • 方法有一个Exception，如果还有是JoinPoint

该方法会在目标方法抛出异常时执行，可以用来做异常的监控程序，检测目标方法执行时是否有异常

throwing属性值为Exception参数

1
2
3
4
5
@AfterThrowing(value = "execution(* *..SomeServiceImpl.doSecond(..))",
                throwing = "ex")
public void myAfterThrowing(Exception ex) {
    System.out.println("异常通知："+ex.getMessage());
}

其执行方式类似于以下代码

1
2
3
4
5
try{
	SomeServiceImpl.doSecond(..);
}catch(Exception ex){
	myAfterThrowing(ex);
}

5.2.9. 最终通知

最终通知总是会执行，并在目标方法之后执行

1
2
3
4
@After(value = "execution(* *..SomeServiceImpl.doThird(..))")
public void myAfter(){
    System.out.println("执行最终通知");
}

其执行方式类似于以下代码

1
2
3
4
5
6
7
try{
     SomeServiceImpl.doThird(..);
}catch(Exception e){

}finally{
    myAfter();
 }

5.2.10. 定义和管理切入点

使用@Pointcut来定义和管理切入点

1
2
3
4
5
6
7
8
9
10
/**
 * @Pointcut 定义和管理切入点，如果切入点表达式是重复的，可以复用
 *      属性：value 切入点表达式
 *      位置：在自定义方法的上面
 * 特点：
 *      当使用@Pointcut定义在一个方法的上面，此时这个方法的名称就是切入点表达式的别名
 *      在其他的通知中，value可以使用这个方法的名称代替切入点表达式
 */
@Pointcut(value = "execution(* *..SomeServiceImpl.doSecond(..))")
public void ex1(){}

当其他方法要使用该切入点时，只需使用该方法名就可以了

1
2
3
4
5
@AfterThrowing(value = "ex1()",
                throwing = "ex")
public void myAfterThrowing(Exception ex) {
    System.out.println("异常通知："+ex.getMessage());
}

5.2.11. cglib代理方式

如果目标类有接口，就是使用jdk的动态代理，如果没有接口，就会使用cglib代理

如何在目标类有接口时也使用cglib呢？需要在声明自动代理生成器的时候指定 proxy-target-class=”true”

1
<aop:aspectj-autoproxy proxy-target-class="true"/>

6. spring整合mybatis

用的技术ioc，因为ioc能创建对象，可以把mybatis框架中的对象交给spring统一创建，开发人员从spring中获取对象。

6.1. 整合步骤

  1. 新建Maven并加入依赖
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
<!--spring依赖-->
  <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-context</artifactId>
     <version>5.2.7.RELEASE</version>
   </dependency>
   <!--aspects依赖-->
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-aspects</artifactId>
     <version>5.2.7.RELEASE</version>
   </dependency>
   <!--做spring事务用到的-->
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-tx</artifactId>
     <version>5.2.7.RELEASE</version>
   </dependency>
   <!--jdbc依赖-->
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-jdbc</artifactId>
     <version>5.2.7.RELEASE</version>
   </dependency>
<!--mybatis依赖-->
   <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis</artifactId>
     <version>3.5.5</version>
   </dependency>
   <!--spring和mybatis整合的依赖-->
   <dependency>
     <groupId>org.mybatis</groupId>
     <artifactId>mybatis-spring</artifactId>
     <version>2.0.5</version>
   </dependency>
<!--mysql依赖-->
   <dependency>
     <groupId>mysql</groupId>
     <artifactId>mysql-connector-java</artifactId>
     <version>8.0.21</version>
   </dependency>
   <!--数据库连接池依赖-->
   <dependency>
     <groupId>com.alibaba</groupId>
     <artifactId>druid</artifactId>
     <version>1.1.12</version>
   </dependency>
 </dependencies>
  1. 创建实体类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
public class Student {
    private Integer id;
    private String name;
    private String email;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", email='" + email + '\'' +
                ", age=" + age +
                '}';
    }

    public Student() {
    }

    public Student(Integer id, String name, String email, Integer age) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.age = age;
    }
}
  1. 创建dao接口和mapper文件
1
2
3
4
5
public interface StudentDao {
    int insertStudent(Student student);

    List<Student> selectStudents();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hjznb.dao.StudentDao">
    <select id="selectStudents" resultType="com.hjznb.domain.Student">
        select * from student
    </select>

    <insert id="insertStudent">
        insert into student values(#{id},#{name},#{email},#{age})
    </insert>
</mapper>
  1. 创建mybatis主配置文件，指定map文件所在包，不需要在此文件中指定数据库了，只需指定map文件
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE configuration
            PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-config.dtd">
    <configuration>
        <!--settings控制mybatis全局行为-->
        <settings>
            <!--设置mybatis输出日志-->
            <setting name="logImpl" value="STDOUT_LOGGING"/>
        </settings>

        <!--sql映射文件的位置,classes文件夹内-->
        <mappers>
            <package name="com.hjznb.dao"/>
        </mappers>
    </configuration>
  2. 创建Service接口和实现类，属性是dao
1
2
3
4
5
public interface StudentService {
    int addStudent(Student student);

    List<Student> queryStudents();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class StudentServiceImpl implements StudentService {
    private StudentDao dao;

    public void setDao(StudentDao dao) {
        this.dao = dao;
    }

    @Override
    public int addStudent(Student student) {
        int num = dao.insertStudent(student);
        return num;
    }

    @Override
    public List<Student> queryStudents() {
        List<Student> students = dao.selectStudents();
        return students;
    }
}
  1. 创建spring的配置文件：声明mybatis的对象交给spring创建：数据源、Dao对象、SqlSessionFactory、声明自定义的service
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

    <!--把数据库的配置信息写在一个独立的文件中-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--声明数据源DataSource，作用是连接数据库-->
    <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <!--set注入
            使用属性配置文件中的数据 格式：${key}
        -->
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!--最大连接数-->
        <property name="maxActive" value="${jdbc.max}"/>
    </bean>

    <!--声明的是mybatis中提供的SqlSessionFactoryBean类，这个类内部创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--把数据库连接池赋给dataSource属性-->
        <property name="dataSource" ref="myDataSource"/>
        <!--
            mybatis主配置文件的位置
            configLocation属性是Resource类型，读取配置文件
            他的赋值使用value，指定文件的路径，使用classpath
        -->
        <property name="configLocation" value="classpath:mybatis.xml"/>
    </bean>

    <!--
        创建dao对象，使用SqlSession的getMapper(StudentDao.class)
        MapperScannerConfigurer:在内部调用getMapper()生成每个dao接口的代理对象
    -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!--指定SqlSessionFactory对象的id-->
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <!--指定包名，包名是dao接口所在的包名。
            MapperScannerConfigurer会扫描这个包中的所有接口，
            把每个接口都执行一次getMapper()方法，得到每个接口的dao对象
            创建好的dao对象放入到spring的容器中
            dao对象的默认名称是 接口名首字母小写
            -->
        <property name="basePackage" value="com.hjznb.dao"/>
    </bean>

    <!--声明service对象-->
    <bean id="studentService" class="com.hjznb.service.impl.StudentServiceImpl">
        <property name="dao" ref="studentDao"/>
    </bean>
</beans>
  1. 创建测试类，获取Service对象，通过service调用dao完成数据库的访问
1
2
3
4
5
6
7
@Test
public void test2(){
    String config = "applicationContext.xml";
    ApplicationContext ac = new ClassPathXmlApplicationContext(config);
    StudentService service = (StudentService) ac.getBean("studentService");
    service.queryStudents().forEach(student -> System.out.println(student));
}

7. spring事务处理

多种数据库的访问技术，有不同的事务处理机制，对象，方法。spring提供一种处理事务的同一模型，能使用统一步骤、方式完成多种不同数据库访问技术的事务处理。

7.1. 事务的类型

要使用spring的事务处理，需要给你的业务方法说明需要事务的类型，需要指明：

  • 事务的隔离级别
  • 事务的超时时间
  • 事务的传播行为

7.1.1. 隔离性

隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。

spring事务的隔离级别有：

  • DEFAULT （默认）：这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别。另外四个与JDBC的隔离级别相对应。
  • READ_UNCOMMITTED（读未提交数据）：允许事务读取未被其他事务提交的变更数据，会出现脏读、不可重复读和幻读问题。
  • READ_COMMITTED（读已提交数据）：只允许事务读取已经被其他事务提交的变更数据，可避免脏读，仍会出现不可重复读和幻读问题。
  • REPEATABLE_READ（可重复读）：确保事务可以多次从一个字段中读取相同的值，在此事务持续期间，禁止其他事务对此字段的更新，可以避免脏读和不可重复读，仍会出现幻读问题。
  • SERIALIZABLE（序列化）：确保事务可以从一个表中读取相同的行，在这个事务持续期间，禁止其他事务对该表执行插入、更新和删除操作，可避免所有并发问题，但性能非常低。

    7.1.2. 传播行为

    事务传播行为（propagation behavior）指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行。

spring定义了7中传播行为，需要在propagation属性中指明
在这里插入图片描述
重点掌握1、2和4

7.1.3. 事务的超时时间

表示一个方法的最长执行时间，超过时间就回滚，单位是秒，默认为-1，没有时限。

7.2. spring框架中提供的事务处理方案

7.2.1. 使用注解@Transactional

步骤：

  1. 声明事务管理器对象
1
2
3
4
5
<!--声明事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!--连接的数据库-->
    <property name="dataSource" ref="myDataSource"/>
</bean>
  1. 开启事务注解驱动，告诉spring框架，我们要用注解的方式管理事务，注意：约束文件处是spring-tx.xsd！！
1
2
3
4
5
<!--
    开启事务注解驱动，告诉spring使用注解管理事务，创建代理对象
    transaction-manager：事务管理器的id
-->
<tx:annotation-driven transaction-manager="transactionManager"/>
  1. 在方法的上面加入注解@Transactional

使用格式：放在方法上面，在属性中指明传播行为，隔离级别，回滚原因，是否为只读。

1
2
3
4
5
6
7
8
9
10
11
@Transactional(
            /*spring事务注解，propagation为传播级别，isolation为隔离级别，rollbackFor为遇到什么异常回滚*/
            propagation = Propagation.REQUIRED,
            isolation = Isolation.DEFAULT,
            readOnly = false,
            timeout = -1,
            rollbackFor = {
                    NullPointerException.class,NotEnoughException.class
            }
    )
 public void buy(Integer goodsId, Integer nums){...}

当不指明属性值的时候，spring默认使用上面的值，但是遇到异常时就回滚。

1
2
3
4
5
@Transactional//默认值为上面的值，遇到运行时异常都会回滚
    @Override
    public void buy(Integer goodsId, Integer nums) {
    	...
    }

spring是使用aop机制，给注解所在类创建代理对象，加入注解功能，在业务方法执行之前先开启事务，在事务方法之后提交或回滚事务，使用aop的环绕通知。

7.2.2. 使用aspectj框架配置事务

注解适用于小型项目，aspectj适用于大型项目，在spring配置文件中声明类、方法需要的事务。这种方式业务方法和事务完全分离。

使用步骤：

  1. 加入aspectj依赖
  2. 声明事务管理器
    1
    2
    3
    4
    5
    <!--声明事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--连接的数据库-->
        <property name="dataSource" ref="myDataSource"/>
    </bean>
  3. 声明方法的事务属性（隔离级别、传播行为、超时）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!--
    使用xml标签声明事务
    id：自定义名称，表示tx:advice标签中的内容
    transaction-manager：事务管理对象id
-->
<tx:advice id="myAdvice" transaction-manager="transactionManager">
    <!--配置事务属性-->
    <tx:attributes>
        <!--给具体的方法配置事务属性，name是完整的方法名，不包含包名和类名-->
        <tx:method name="buy" isolation="DEFAULT" propagation="REQUIRED"
                   rollback-for="com.hjznb.excep.NotEnoughException,java.lang.NullPointerException"/>
        <!--spring会先处理完整方法名的，再处理带通配符的，最后处理全通配符的-->
        <tx:method name="add*"/>
        <tx:method name="*" read-only="true" propagation="SUPPORTS"/>
    </tx:attributes>
</tx:advice>
  1. 指定aop，指定哪些类要创建代理，因为此时只是指定了方法名和事务，并没有说给哪个类
1
2
3
4
5
6
7
8
9
10
11
12
<!--配置aop-->
<aop:config>
    <!--配置切入点表达式：指定那些包中的类要使用事务
        id：切入点表达式的名称，唯一值
        expression：切入点表达式，指定哪些类要使用事务，aspectj会创建代理对象

        -->
    <aop:pointcut id="servicePt" expression="execution(* *..service..*.*(..))"/>

    <!--配置增强器：关联advice和pointcut-->
    <aop:advisor advice-ref="myAdvice" pointcut-ref="servicePt"/>
</aop:config>

8. 解决类目录中没有spring配置文件

在pom中加入插件依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
        <filtering>false</filtering>
    </resource>
</resources>
赏

谢谢你请我吃糖果

支付宝
微信

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一名在校的大学生<br><br>梦想是成为一名优秀的程序员(划掉)，icer！