Spring精华个人总结

最新推荐文章于 2024-08-15 14:47:41 发布

莫枢

最新推荐文章于 2024-08-15 14:47:41 发布

阅读量185

点赞数

分类专栏： Spring 文章标签： java Spring IOC AOP

本文链接：https://blog.csdn.net/xingranzhihuo/article/details/118730481

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

Spring精华个人总结

Spring框架概述

Spring是轻量级的开源的JavaEE框架
Spring可以解决企业应用开发的复杂性
Spring有两个核心部分: IOC 和AOP：
1. IOC: 控制反转，把创建对象过程交给Spring进行；
2. AOP: 面向切面，不修改源代码进行功能增强。
Spring特点
1. 方便解耦，简化开发；
2. AOP编程支持；
3. 方便程序测试；
4. 方便和其他框架进行整合；
5. 方便进行事务操作；
  6）降低API开发难度。

Spring入门案例

背景：

通过IDEA创建好一个普通的java项目。
IDEA中已经创建好一个普通类，并导入所需入门级jar包，包括

创建Spring配置文件，在配置文件中创建对象

在项目的包下直接创建一个spring config文件，并命名为bean1.xml。

创建对象具体过程见代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置User对象的创建 -->
    <bean id="user" class="com.yhh.spring5.User"/>
</beans>

测试代码编写

在包下建立测试所用的包以及类，随便取名。项目结构如下：

代码如下。

package com.yhh.spring5.testdemo;

import com.yhh.spring5.User;
import javafx.application.Application;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.GenericApplicationContext;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/11 17:47
 */

public class TestSpring5 {
    @Test
    public void testAdd() {
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        // 获取配置中的创建对象
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();
    }
}

IOC容器底层原理

IOC概念

(1) 控制反转，把对象创建和对象之间的调用过程，交给Spring进行管理。
(2) 使用IOC目的: 为了耦合度降低。
(3) 做入门案例就是IOC实现。

IOC底层原理

用到的技术：xml解析，工厂模式，反射。

IOC演变过程

① UserService类通过new 创建对象调用UserDao类定义的方法

②采用工厂模式降低耦合性

③利用反射技术达到更好地效果，这也是IOC的底层原理

IOC的具体过程：

第一步通过xml配置文件创建对象。

<bean id="dao" class="com.yhh.spring5.UserDao"/>

第二步利用UserService类和UserDao类来创建工厂类，下面是伪代码。

class UserFactory {
    // 为了方便调用，直接定义为静态方法
    public static UserDao getDao () {
        // xml解析，得到对应的类
        String classValue = class属性值;
        // 利用反射创建对象
        Class clazz = Class.forName(classValue);
        return (UserDao)clazz.newInstance();
    }
}

IOC就使得解耦合更加彻底，降低耦合度。

IOC接口

1、IOC思想基于IOC容器完成，IOC容器底层就是对象工厂；
2、Spring 提供IOC容器实现两种方式: (两个接口) ：

BeanFactory：IOC容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用；

加载配置文件时不会创建对象，只有在使用或者获取这个对象时采取创建这个对象。
ApplicationContext：BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。

加载配置文件时就会创建对象。（开发中常用模式，把创建对象交给服务器，一启动就创建好，拿来即用）

ApplicationContext主要实现类

IOC操作Bean管理

Bean管理的概念

Spring创建对象
Spring注入属性

Bean管理操作实现方式

基于xml配置文件方式实现
基于注解方式实现

基于xml配置文件方式实现

1.基于xml方式创建对象

<bean id="user" class="com.yhh.spring5.User"/>

(1) 在spring配置文件中，利用bean标签，在里面添加对应属性，实现对象创建。

(2) bean标签的常用属性介绍：

id属性：给对象取一个名字，唯一标识；
class属性：创建对象所在类的全路径（包类路径）。

(3) 在创建对象时，默认使用无参构造器。

2.基于xml方式注入属性

(1) DI(依赖注入)：注入属性

第一种注入方式：set方法注入；

(1) 创建类，定义属性和对应的set方法；

package com.yhh.spring5;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/11 15:50
 */

public class User {

    // 创建属性
    private String userName;
    private int age;

    // 创建set方法
    public void setUserName(String userName) {
        this.userName = userName;
    }

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

    public void add() {
        System.out.println("add...");
    }
}

(2) 在spring配置文件中创建对象，并配置属性注入。

User类：

package com.yhh.spring5;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/11 15:50
 */

public class User {

    // 创建属性
    private String userName;
    private int age;

    // 创建set方法
    public void setUserName(String userName) {
        this.userName = userName;
    }

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

    public void add() {
        System.out.println("add...");
    }
	// 这里只是展示set方法赋值，spring里面不是直接new对象，测试代码时会删除main方法
    public static void main(String[] args) {
        User user = new User();
        user.setUserName("master");
    }
}

bean1.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 配置User对象的创建 -->
    <bean id="user" class="com.yhh.spring5.User">
    <!-- set方法注入属性
    name属性：User类中的属性名
    value属性：对User类中将要注入的属性的赋值
    -->
        <property name="userName" value="YHH"/>
        <property name="age" value="21"/>
    </bean>
</beans>

测试代码（testdemo.java）:

package com.yhh.spring5.testdemo;

import com.yhh.spring5.User;
import javafx.application.Application;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.GenericApplicationContext;

/**
 * 测试xml方式set方法注入属性
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/11 17:47
 */

public class TestSpring5 {
    @Test
    public void testAdd() {
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        // 获取配置中的创建对象
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();
    }
}

结果展示：

第二种注入方式：有参构造器注入。

(1) 创建类，定义属性，创建属性对应有参数的构造器；

Order类：

package com.yhh.spring5;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/11 23:42
 */

public class Order {
    private String oname;
    private String address;

    public Order(String oname, String address) {
        this.oname = oname;
        this.address = address;
    }
}

(2) 在spring配置文件中进行配置；

<!-- 利用有参构造器注入属性 -->
    <bean id="order" class="com.yhh.spring5.Order">
        <constructor-arg name="oname" value="CPU"/>
        <constructor-arg name="address" value="China"/>
    </bean>

测试代码（testdemo.java）:

package com.yhh.spring5.testdemo;

import com.yhh.spring5.Order;
import com.yhh.spring5.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/11 17:47
 */

public class TestSpring5 {
    @Test
    public void testAdd() {
        // *******第一种注入方式：采用set方法******************
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        // 获取配置中的创建对象
        User user = context.getBean("user", User.class);
        System.out.println(user);
        user.add();
        // *******第二种注入方式：采用有参构造器******************
        //ApplicationContext context1 = new ClassPathXmlApplicationContext("bean1.xml");
        // 获取配置中的创建对象
        Order order = context.getBean("order", Order.class);
        System.out.println(order);
        order.testPrint();
    }
}

结果展示：

3.基于xml注入其他类型属性

字面量：

null值
属性值包含特殊符号

null值注入：

bean1.xml:

<bean id="user" class="com.yhh.spring5.User">
	<property name="userName" value="YHH"/>
	<property name="age" value="21"/>
	<property name="address">
		<null></null>
	</property>
</bean>

属性值包含特殊符号注入：

<bean id="user" class="com.yhh.spring5.User">
	<property name="userName" value="YHH"/>
	<property name="age" value="21"/>
	<!-- 属性值种含有特殊符号尖括号时
		1 把<>进行转义，&lt;&gt;
		2 把特殊符号写到CDATA里面，其格式在下面代码里
	-->
	<property name="address">
		<value><![CDATA[<<南京>>]]></value>
	</property>
</bean>

4.基于xml注入外部bean

(1) 创建两个类，service类和dao类

UserService.java:

package com.yhh.spring5.service;

import com.yhh.spring5.dao.UserDao;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 11:39
 */

public class UserService {
    // 创建UserDao类型属性，生成set方法
    private UserDao userDao;

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

    public void add() {
        System.out.println("UserService add>>>...");
        userDao.update();
    }

}

UserDaoImpl.java:

package com.yhh.spring5.dao;

import com.yhh.spring5.User;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 11:40
 */

public class UserDaoImpl implements UserDao {
    @Override
    public void update() {
        System.out.println("UserDao...");
    }
}

(2) 在service调用dao的方法

见上面代码块

(3) 在spring配置文件中配置

bean2.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 创建UserService和UserDao对象-->
    <bean id="userService" class="com.yhh.spring5.service.UserService">
        <!-- 注入userDao对象
        name属性：类里面的属性名称
        ref属性：创建userDaoImpl对象bean标签id值
        -->
        <property name="userDao" ref="userDaoImpl"></property>
    </bean>
    <bean id="userDaoImpl" class="com.yhh.spring5.dao.UserDaoImpl"/>
</beans>

(4)测试代码：

package com.yhh.spring5.testdemo;

import com.yhh.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 11:57
 */

public class TestBean {
    @Test
    public void testBean() {
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        // 获取配置中的创建对象
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }
}

5.基于xml注入内部bean

例

Dept类：

package com.yhh.spring5.bean;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 15:44
 */

public class Dept {
    private String dname;

    public void setDname(String dname) {
        this.dname = dname;
    }

    @Override
    public String toString() {
        return "Dept{" +
                "dname='" + dname + '\'' +
                '}';
    }
}

Emp类：

package com.yhh.spring5.bean;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 15:47
 */

public class Emp {
    private String ename;
    private String gender;
    // 员工所属部门
    private Dept dept;

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

bean3.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 创建UserService和UserDao对象-->
    <bean id="emp" class="com.yhh.spring5.bean.Emp">
        <property name="ename" value="Tom"/>
        <property name="gender" value="man"/>
        <property name="dept">
            <bean id="dept" class="com.yhh.spring5.bean.Dept">
                <property name="dname" value="security department"/>
            </bean>
        </property>
    </bean>
</beans>

测试代码：

package com.yhh.spring5.testdemo;

import com.yhh.spring5.bean.Emp;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 11:57
 */

public class TestBean {
    @Test
    public void testBean() {
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        // 获取配置中的创建对象
        Emp emp = context.getBean("emp", Emp.class);
        System.out.println(emp);
    }
}

6.基于xml进行级联赋值

方法一：

在spring配置文件中配置即可，测试代码就略过。

bean.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 创建UserService和UserDao对象-->
    <bean id="emp" class="com.yhh.spring5.bean.Emp">
        <property name="ename" value="Tom"/>
        <property name="gender" value="man"/>
        <property name="dept" ref="dept"/>
    </bean>
    <!--以外部bean注入属性方式进行级联赋值-->
    <bean id="dept" class="com.yhh.spring5.bean.Dept">
        <property name="dname" value="security department"/>
    </bean>
</beans>

方法二：

结合被引用对象的get方法配置spring配置文件完成级联赋值

Emp类：

package com.yhh.spring5.bean;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 15:47
 */

public class Emp {
    private String ename;
    private String gender;
    // 员工所属部门
    private Dept dept;

    public Dept getDept() {
        return dept;
    }

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "ename='" + ename + '\'' +
                ", gender='" + gender + '\'' +
                ", dept=" + dept +
                '}';
    }
}

bean.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 创建UserService和UserDao对象-->
    <bean id="emp" class="com.yhh.spring5.bean.Emp">
        <property name="ename" value="Tom"/>
        <property name="gender" value="man"/>
        <property name="dept" ref="dept"/>
        <property name="dept.dname" value="HR department"/>
    </bean>
    <!--以外部bean注入属性方式进行级联赋值-->
    <bean id="dept" class="com.yhh.spring5.bean.Dept"/>
</beans>

7.基于xml注入集合类型

Student类：

package collectiontype;

import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 17:43
 */

public class Student {
    // 数组类型属性
    private String[] courses;

    // 集合类型属性
    private List<String> list;

    // Map类型属性
    private Map<String, String> map;

    public void setCourses(String[] courses) {
        this.courses = courses;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public String toString() {
        return "Student{" +
                "courses=" + Arrays.toString(courses) +
                ", list=" + list +
                ", map=" + map +
                '}';
    }
}

bean.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="collectiontype.Student">
        <!-- 数组属性注入 -->
        <property name="courses">
            <array>
                <value>Java</value>
                <value>Redis</value>
                <value>MySQL</value>
                <value>MongoDB</value>
            </array>
        </property>
        <!-- List属性注入 -->
        <property name="list">
            <list>
                <value>Java</value>
                <value>Redis</value>
                <value>MySQL</value>
                <value>MongoDB</value>
            </list>
        </property>
        <!-- Map属性注入 -->
        <property name="map">
            <map>
                <entry key="Java" value="98"/>
                <entry key="MySQL" value="99"/>
            </map>
        </property>
    </bean>
</beans>

测试代码：

package collectiontype.testdemo;

import collectiontype.Student;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.sql.SQLOutput;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 18:07
 */

public class TestDemo {
    @Test
    public void testBean () {
        // *******第一种注入方式：采用set方法******************
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 获取配置中的创建对象
        Student student = context.getBean("student", Student.class);
        System.out.println(student);
    }
}

注意，如果注入集合类型为对象集合，情况特殊：

Course类：（作为Student类的一个属性类型）

package collectiontype;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/12 18:30
 */

public class Course {
    private String course;

    public void setCourse(String course) {
        this.course = course;
    }

    @Override
    public String toString() {
        return "Course{" +
                "course='" + course + '\'' +
                '}';
    }
}

bean.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="student" class="collectiontype.Student">
        <!-- 数组属性注入 -->
        <property name="courses">
            <array>
                <value>Java</value>
                <value>Redis</value>
                <value>MySQL</value>
                <value>MongoDB</value>
            </array>
        </property>
        <!-- List属性注入 -->
        <property name="list">
            <list>
                <value>Java</value>
                <value>Redis</value>
                <value>MySQL</value>
                <value>MongoDB</value>
            </list>
        </property>
        <!-- Map属性注入 -->
        <property name="map">
            <map>
                <entry key="Java" value="98"/>
                <entry key="MySQL" value="99"/>
            </map>
        </property>
        <!-- 新增集合为对象集合 -->
        <property name="courseList">
            <list>
                <ref bean="course1"/>
                <ref bean="course2"/>
                <ref bean="course3"/>
            </list>
        </property>
    </bean>
    <bean id="course1" class="collectiontype.Course">
        <property name="course" value="Spring框架课程"/>
    </bean>
    <bean id="course2" class="collectiontype.Course">
        <property name="course" value="MyBatis课程"/>
    </bean>
    <bean id="course3" class="collectiontype.Course">
        <property name="course" value="Java课程"/>
    </bean>
</beans>

测试代码略。

提取注入的集合部分，即做到复用集合元素。

bean.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       // 加入util名称空间
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <!-- 提取list集合属性引入 -->
    <util:list id="bookList">
            <value>Java</value>
            <value>Redis</value>
            <value>MySQL</value>
    </util:list>
    <!-- 使用被提取出来的集合属性 -->
    <bean id="book" class="collectiontype.Book">
        <property name="list" ref="bookList"/>
    </bean>
</beans>

FactoryBean(工厂bean)

Spring有两种类型bean,一种普通bean,另外一种工厂bean (FactoryBean)
普通bean:在配置文件中定义bean类型就是返回类型。
工厂bean:在配置文件定义bean类型可以和返回类型不一样。

工厂bean例

MyBean类：

package collectiontype;

import org.springframework.beans.factory.FactoryBean;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 11:44
 */

public class MyBean implements FactoryBean<Course> {

    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCourse("Java");
        return course;
    }

    @Override
    public Class<?> getObjectType() {
        return null;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }
}

Bbean.xml:

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

测试代码：

@Test
    public void testMyBean() {
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        // 获取配置中的创建对象
        Course course = context.getBean("myBean", Course.class);
        System.out.println(course);
    }

自定义MyBean类通过实现工厂Bean接口；重写getObject()方法返回泛型所指的对象类型，使得最终调用的类型就是泛型的类型。

bean的作用域

在Spring中，设置创建bean实例是单实例还是多实例；

在Spring中，默认情况下bean是单实例对象。（就是说每次获取配置中的创建对象地址相同，为同一对象）

如何设置bean是单实例还是多实例？

在Spring配置文件中bean标签里面有scope属性用于设置单实例还是多实例；

singleton，默认值，单实例对象
prototype，多实例对象

多实例对象例

bean.xml：

<util:list id="bookList">
	<value>Java</value>
	<value>Redis</value>
	<value>MySQL</value>
</util:list>
<!-- 使用被提取出来的集合属性 ，添加scope属性，并设置为prototype-->
<bean id="book" class="collectiontype.Book" scope="prototype">
	<property name="list" ref="bookList"/>
</bean>

测试代码：（不去重写toString方法，打印对象地址值）

 @Test
    public void testBean () {
        // *******第一种注入方式：采用set方法******************
        // 加载spring配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        // 获取配置中的创建对象
        Book book = context.getBean("book", Book.class);
        Book book1 = context.getBean("book", Book.class);
        System.out.println(book);
        System.out.println(book1);
    }

结果展示：

很明显此时两个实例化Book对象地址不同，说明bean此时是多实例对象。

这里简单说一下singleton和prototype区别：

singleton代表单实例，prototype代表多实例；
设置bean的scope属性为singleton时，加载spring配置文件时就会创建实例对象；而设置为prototype时，在调用getBean()方法时才创建实例对象。

bean的生命周期

1.生命周期

从对象创建到销毁的过程

2.bean的生命周期

(1) 通过构造器创建bean实例（无参构造器）

(2) 为bean的属性设置值以及对其他bean的引用（调用set方法）

(3) 调用bean的初始化的方法(需要进行配置初始化的方法)

(4) bean可以使用了(对象获取到了)

(5) 当容器关闭时候，调用bean的销毁的方法(需要进行配置销毁的方法)

3.bean的生命周期举例

bean.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--这里定义了初始化和销毁对象的方法-->
	<bean id="order" class="collectiontype.Order" init-method="initMethod" destroy-method="destroyMethod">
		<property name="oname" value="abc"/>
	</bean>
</beans>

自定义类Order:

package collectiontype;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 19:49
 */

public class Order {
    private String oname;
    // 自定义无参构造器
    public Order() {
        System.out.println("1、调用无参构造器...");
    }
    public void setOname(String oname) {
        this.oname = oname;
        System.out.println("2、调用set方法设置属性...");
    }
    public void initMethod() {
        System.out.println("3、调用初始化方法...");
    }
    public void destroyMethod() {
        System.out.println("5、调用销毁方法...");
    }
}

测试代码：

    @Test
    public void testMyBean1() {
        // 加载spring配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean4.xml");
        // 获取配置中的创建对象
        Order order = context.getBean("order", Order.class);
        System.out.println("4、获取创建bean实例对象...");
        System.out.println(order);
        context.close();
    }

结果展示：

4.bean的后置处理器，bean生命周期有七步

(1) 通过构造器创建bean实例（无参构造器）

(2) 为bean的属性设置值以及对其他bean的引用（调用set方法）

(3) 把bean实例传递到bean后置处理器的方法postProcessBeforeInitialization

(4) 调用bean的初始化的方法(需要进行配置初始化的方法)

(5) 把bean实例传递到bean后置处理器的方法postProcessAfterInitialization

(6) bean可以使用了(对象获取到了)

(7) 当容器关闭时候，调用bean的销毁的方法(需要进行配置销毁的方法)

5.演示添加bean的后置处理器效果

(1) 创建类，实现BeanPostProcessor接口，创建后置处理器；

MyBeanPost类（自定义后置处理器）：

package collectiontype;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 20:12
 */

public class MyBeanPost implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之前执行的方法");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("在初始化之后执行的方法");
        return bean;
    }
}

(2) 配置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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="order" class="collectiontype.Order" init-method="initMethod" destroy-method="destroyMethod">
        <property name="oname" value="abc"/>
    </bean>
    <!-- 配置后置处理器 -->
    <bean id="myBeanPost" class="collectiontype.MyBeanPost"/>
</beans>

xml自动装配

概念：根据指定装配规则(属性名称或者属性类型)，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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--实现自动装配
    bean标签属性autowire,配置自动装配
    autowire属性常用两个值：
        byName 根据属性名称注入：注入值bean的id值和类属性名称相同，如这里的dept属性
        byType 根据属性类型注入
    -->
    <bean id="emp" class="collectiontype.autowire.Emp" autowire="byName">
        <!--<property name="dept" ref="dept"/>-->
    </bean>
    <bean id="dept" class="collectiontype.autowire.Dept"/>
</beans>

根据属性类型自动装配注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--实现自动装配
    bean标签属性autowire,配置自动装配
    autowire属性常用两个值：
        byName 根据属性名称注入：注入值bean的id值和类属性名称相同，如这里的dept属性
        byType 根据属性类型注入: 注入值bean的类和类属性对应的类相同，如这里的Dept类
    -->
    <bean id="emp" class="collectiontype.autowire.Emp" autowire="byType">
        <!--<property name="dept" ref="dept"/>-->
    </bean>
    <bean id="dept" class="collectiontype.autowire.Dept"/>
</beans>

外部属性文件

例

1、直接配置数据库信息

先导入druid的jar包，再手动配置德鲁伊连接池。

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--直接配置连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/userDb"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
</beans>

2、引入外部属性文件配置数据库连接池

(1) 创建外部属性文件，properties格式文件，写入数据库信息、

# 左边随便自己定义即可，避免重复
prop.driverClass=com.mysql.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/userDb
prop.userName=root
prop.password=123456

(2) 把外部properties格式文件引入spring配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!--suppress SpringFacetInspection -->
<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">
    <!--直接配置连接池-->
<!--    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">-->
<!--        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>-->
<!--        <property name="url" value="jdbc:mysql://localhost:3306/userDb"/>-->
<!--        <property name="username" value="root"/>-->
<!--        <property name="password" value="123456"/>-->
<!--    </bean>-->
    <!-- 通过标签context引入外部配置文件 -->
    <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClass}"/>
        <property name="url" value="${prop.url}"/>
        <property name="username" value="${prop.userName}"/>
        <property name="password" value="${prop.password}"/>
    </bean>
</beans>

基于注解方式（Bean管理）

1、什么是注解？

(1)、注解是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值…)；

(2)、使用注解，注解作用在类上，方法上，属性上；

(3)、使用注解目的：简化xml配置

2、Spring针对Bean管理中创建对象提供的注解

(1)、@Component

(2)、@Service

(3)、@Controller

(4)、@Repository

上面四个注解功能相同，都可以用来创建bean实例。

3、基于注解方式创建对象

(1)、引入AOP依赖jar包

(2)、开启组件扫描

<?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">
    <!--开启组件扫描
    如果需要扫描多个包：
    1、多个包在base-package中用逗号隔开；
    2、扫描多个包的上层目录
    -->
    <context:component-scan base-package="com.yhh.springdemo2"/>
</beans>

(3)、创建类，在类上面添加创建对象的注解

package com.yhh.springdemo2.service;

import org.springframework.stereotype.Component;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:27
 */

/**
 * 在注解里面value属性值可以省略不写
 * 默认值为将类名称首字母小写后的字符串
 */
@Component(value = "userService")// <bean id="userService" class="..."/>
public class UserService {

    public void add() {
        System.out.println("Service add...");
    }
}

4、组件扫描配置

<?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">
    <!--开启组件扫描
    如果需要扫描多个包：
    1、多个包在base-package中用逗号隔开；
    2、扫描多个包的上层目录
    -->
    <context:component-scan base-package="com.yhh.springdemo2"/>
    <!--示例1
    use-default-filters="false"表示现在不使用默认filter,自己配置filter
    context:include-filter: 设置扫描哪些内容
    -->
    <context:component-scan base-package="com.yhh.springdemo2" use-default-filters="false">
        <context:include-filter type="annotation"
                                expression=" org.springframework.stereotype.Controller" />
    </context:component-scan>
    <!--示例2
    下面配置扫描包所有内容
    context:exclude-filter:
    设置哪些内容不进行扫描
    -->
    <context:component-scan base-package="com.yhh.springdemo2">
        <context:exclude-filter type="annotation"
                                expression=" org.springframework.stereotype.Controller" />
    </context:component-scan>
</beans>

5、基于注解方式实现属性注入

(1)、@AutoWired：根据属性类型自动装配

① 在UserService类和UserDaoImpl类中添加注解创建对象

UserService类：

package com.yhh.springdemo2.service;

import com.yhh.springdemo2.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:27
 */

/**
 * 在注解里面value属性值可以省略不写
 * 默认值为将类名称首字母小写后的字符串
 */
@Service
public class UserService {
    public void add() {
        System.out.println("Service add...");
        userDao.add();
    }
}

UserDaoImpl类：

package com.yhh.springdemo2.dao;

import org.springframework.stereotype.Repository;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:55
 */
@Repository
public class UserDaoImpl implements UserDao{

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

② 在UserService类中注入UserDao对象，即在UserService类中添加UserDao类属性，并在属性上使用注解

package com.yhh.springdemo2.service;

import com.yhh.springdemo2.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:27
 */

/**
 * 在注解里面value属性值可以省略不写
 * 默认值为将类名称首字母小写后的字符串
 */
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    public void add() {
        System.out.println("Service add...");
        userDao.add();
    }
}

(2)、@Qualifier：根据属性名称注入，且和@AutoWired一起使用

package com.yhh.springdemo2.service;

import com.yhh.springdemo2.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:27
 */

/**
 * 在注解里面value属性值可以省略不写
 * 默认值为将类名称首字母小写后的字符串
 */
@Service
public class UserService {
    // 不需要添加set方法
    // 结合属性名称和类型注入属性
    @Autowired
    @Qualifier(value = "userDaoImpl1")
    private UserDao userDao;
    public void add() {
        System.out.println("Service add...");
        userDao.add();
    }
}

(3)、@Resource：可以根据属性类型注入，也可以根据属性名称注入

package com.yhh.springdemo2.service;

import com.yhh.springdemo2.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:27
 */

@Service
public class UserService {
    //@Resource
    @Resource(name = "userDaoImpl1")
    private UserDao userDao;
    public void add() {
        System.out.println("Service add...");
        userDao.add();
    }
}

(4)、@Value：注入普通属性类型，例如字符串，整型等等

package com.yhh.springdemo2.service;

import com.yhh.springdemo2.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class UserService {
    @Value(value = "abc")
    private String name;
    //@Resource
    @Resource(name = "userDaoImpl1")
    private UserDao userDao;
    public void add() {
        System.out.println("Service add..." + name);
        userDao.add();
    }
}

完全注解开发

创建配置类，替代xml配置文件

SpringConfig类

package com.yhh.springdemo2.config;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 0:38
 */
// 作为配置类，替代配置文件
@Configuration
@ComponentScan(basePackages = "com.yhh.springdemo2")
public class SpringConfig {

}

测试代码：

package com.yhh.springdemo2;

import com.yhh.springdemo2.config.SpringConfig;
import com.yhh.springdemo2.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:16
 */

public class TestDemo {
    @Test
    public void testDemo1 () {
        // 注意区别，这里不再是加载spring配置文件，而是自定义的配置类
        ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService);
        userService.add();
    }
}

AOP基本概念

面向切面编程(方面)，利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP底层原理

1、AOP底层使用动态代理

(1) 有两种情况动态代理

① 有接口情况，使用JDK动态代理

② 无接口情况，使用CGLIB动态代理

2、JDK动态代理实现

JDK动态代理在java.lang.reflect.Proxy类里面

(1)、调用Proxy.java类中newProxyInstance()方法

方法中的三个参数：

loader：类加载器
interfaces：增强方法所在类实现的接口，可以支持多个接口
h：实现这个接口InvocationHandler，创建代理对象，实现增强方法

(2)、编写代码

① 创建接口，定义方法

UserDao接口：

package com.yhh.springdemo2.dao;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:55
 */

public interface UserDao {
    public int add(int a, int b);
    public String update(String id);
}

② 创建接口实现类并实现方法

UserDaoImpl.java：

package com.yhh.springdemo2.dao;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/13 22:55
 */
public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        return a + b;
    }

    @Override
    public String update(String id) {
        return id;
    }
}

③ 使用Proxy类创建接口对象

测试代码（整合自定义实现InvocationHandler接口的类）：

package com.yhh.springdemo2.proxy;

import com.yhh.springdemo2.dao.UserDao;
import com.yhh.springdemo2.dao.UserDaoImpl;

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

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 7:59
 */

public class JDKProxy {
    public static void main(String[] args) {
        // 创建接口实现类的代理对象
        Class[] interfaces = {UserDao.class};
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserProxy(userDao));
        int res = dao.add(1, 2);
        System.out.println("结果为：" + res);
    }
}
// 创建代理对象
class UserProxy implements InvocationHandler{
    // 通过有参构造器传递代理对象对应的类
    private Object obj;
    public UserProxy (Object obj) {
        this.obj = obj;
    }
    // 增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法之前执行
        System.out.println("方法之前执行..." + method.getName() + ": 传递的参数..." + Arrays.toString(args));
        // 被增强的方法执行
        Object res = method.invoke(obj, args);
        // 方法之后执行
        System.out.println("方法之后执行..." + obj);
        return res;
    }
}

结果展示：

2021-07-14_082950

AOP操作术语

1、连接点

类里面哪些方法可以被增强，这些方法称为连接点

2、切入点

实际被真正增强的方法，称为切入点

3、通知（增强）

(1)实际增强的逻辑部分称为通知(增强)

(2)通知类型

前置通知
后置通知
环绕通知
异常通知
最终通知

4、切面

是一个动作，把通知应用到切入点的过程

AOP操作准备工作

1、Spring框架一般都是基于AspectJ实现AOP操作

AspectJ不是Spring组成部分，独立AOP框架，一般把AspectJ和Spring框架一起使用，进行AOP操作。

2、基于AspectJ实现AOP操作

(1)、基于xml配置文件实现；

(2)、基于注解方式实现。（主要使用方式）

3、引入AOP相关依赖

4、切入表达式

(1) 切入点表达式作用:知道对哪个类里面的哪个方法进行增强
(2) 语法结构:
execution([权限修饰符] [返回类型] [类全路径]方法名称 )。

例1: 对com.yhh.dao.BookDao类里面的add进行增强。
execution(* com.yhh.dao.BookDao.add(…))

例2: 对com.yhh.dao.BookDao类里面的所有的方法进行增强。
execution(* com.yhh.dao.BookDao.*(…))

例3: 对com.yhh.dao包所有类里面的所有的方法进行增强。
execution(* com.yhh.dao.*.*(…))

AspectJ注解

1、创建类，在类里面定义方法

package com.yhh.springdemo2.aop;

/**
 * 创建类，在类里面定义方法
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 14:36
 */

public class User {
    public void add() {
        System.out.println("add......");
    }
}

2、创建增强类，编写增强逻辑

package com.yhh.springdemo2.aop;

/**
 * 创建增强类，编写增强逻辑
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 14:38
 */
public class UserProxy {
    // 前置通知
    public void before() {
        System.out.println("before......");
    }
}

3、进行通知配置

(1) 在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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.yhh.springdemo2.aop"/>
</beans>

(2) 使用注解创建User类和UserProxy类对象

User类：

package com.yhh.springdemo2.aop;

import org.springframework.stereotype.Component;

/**
 * 创建类，在类里面定义方法
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 14:36
 */

@Component
public class User {
    public void add() {
        System.out.println("add......");
    }
}

UserProxy类：

package com.yhh.springdemo2.aop;

import org.springframework.stereotype.Component;

/**
 * 创建增强类，编写增强逻辑
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 14:38
 */
@Component
public class UserProxy {
    // 前置通知
    public void before() {
        System.out.println("before......");
    }
}

(3) 在增强类上面添加AspectJ注解

package com.yhh.springdemo2.aop;

import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

/**
 * 创建增强类，编写增强逻辑
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 14:38
 */
@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 前置通知
    public void before() {
        System.out.println("before......");
    }
}

(4) 在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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--开启注解扫描-->
    <context:component-scan base-package="com.yhh.springdemo2.aop"/>
    <!--开启Aspect生成代理对象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

4、配置不同类型通知

使用切入点表达式结合注解完成通知类型

package com.yhh.springdemo2.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 创建增强类，编写增强逻辑
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 14:38
 */
@Component
@Aspect // 生成代理对象
public class UserProxy {
    // 前置通知
    @Before(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void before() {
        System.out.println("before......");
    }
    // 后置通知
    @After(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void after() {
        System.out.println("after......");
    }
    // 最终通知
    @AfterReturning(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void afterReturning() {
        System.out.println("AfterReturning......");
    }
    // 异常通知
    @AfterThrowing(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing......");
    }
    // 环绕通知
    @Around(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前......");
        // 被增强的方法
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后......");
    }
}

5、相同切入点抽取

package com.yhh.springdemo2.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * 创建增强类，编写增强逻辑
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 14:38
 */
@Component
@Aspect // 生成代理对象
public class UserProxy {
    @Pointcut(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void pointdemo() {

    }
    // 前置通知
    @Before(value = "pointdemo()")
    public void before() {
        System.out.println("before......");
    }
    // 后置通知
    @After(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void after() {
        System.out.println("after......");
    }
    // 最终通知
    @AfterReturning(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void afterReturning() {
        System.out.println("AfterReturning......");
    }
    // 异常通知
    @AfterThrowing(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing......");
    }
    // 环绕通知
    @Around(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕之前......");
        // 被增强的方法
        proceedingJoinPoint.proceed();
        System.out.println("环绕之后......");
    }
}

6、有多个增强类对同一方法进行增强，设置增强类的优先级

在增强类上面添加注解@Order(数字类型值)，数字类型值越小优先级越高。从0开始。

新增强类PersonProxy：

package com.yhh.springdemo2.aop;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 15:26
 */
@Component
@Aspect
@Order(1)
public class PersonProxy {
    // 前置通知
    @Before(value = "execution(* com.yhh.springdemo2.aop.User.add(..))")
    public void before() {
        System.out.println("Person before......");
    }
}

AspectJ配置文件实现

1、创建两个类，增强类和被增强类，创建方法；

Book类：

package com.yhh.springdemo2.aopxml;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 15:36
 */

public class Book {
    public void buy() {
        System.out.println("buy...");
    }
}

BookProxy类：

package com.yhh.springdemo2.aopxml;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 15:36
 */

public class BookProxy {
    public void before() {
        System.out.println("before...");
    }
}

2、在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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--创建两个类对象-->
    <bean id="book" class="com.yhh.springdemo2.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.yhh.springdemo2.aopxml.BookProxy"></bean>
</beans>

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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--创建两个类对象-->
    <bean id="book" class="com.yhh.springdemo2.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.yhh.springdemo2.aopxml.BookProxy"></bean>
    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.yhh.springdemo2.aopxml.Book.buy(..))"/>
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

测试代码略。

AspectJ完全注解开发

创建配置类替代spring配置文件

package com.yhh.springdemo2.aopxml;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 15:56
 */
@Configuration
@ComponentScan(basePackages = {"com.yhh.springdemo2.aopxml"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AOPConfig {

}

                       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--创建两个类对象-->
<bean id="book" class="com.yhh.springdemo2.aopxml.Book"></bean>
<bean id="bookProxy" class="com.yhh.springdemo2.aopxml.BookProxy"></bean>

```

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"
       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/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--创建两个类对象-->
    <bean id="book" class="com.yhh.springdemo2.aopxml.Book"></bean>
    <bean id="bookProxy" class="com.yhh.springdemo2.aopxml.BookProxy"></bean>
    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.yhh.springdemo2.aopxml.Book.buy(..))"/>
        <aop:aspect ref="bookProxy">
            <!--增强作用在具体方法上-->
            <aop:before method="before" pointcut-ref="p"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

测试代码略。

AspectJ完全注解开发

创建配置类替代spring配置文件

package com.yhh.springdemo2.aopxml;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

/**
 * @author masterYHH
 * @version 1.0
 * @date 2021/7/14 15:56
 */
@Configuration
@ComponentScan(basePackages = {"com.yhh.springdemo2.aopxml"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class AOPConfig {

}

莫枢

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring精华个人总结

Spring精华个人总结Spring框架概述Spring是轻量级的开源的JavaEE框架Spring可以解决企业应用开发的复杂性Spring有两个核心部分: IOC 和AOP：IOC: 控制反转，把创建对象过程交给Spring进行；AOP: 面向切面，不修改源代码进行功能增强。Spring特点方便解耦，简化开发；AOP编程支持；方便程序测试；方便和其他框架进行整合；方便进行事务操作；6）降低API开发难度。Spring入门案例背景：通过IDEA创建好一个普通
复制链接

扫一扫

专栏目录