Spring--01

最新推荐文章于 2024-07-26 00:55:46 发布

安菲尔德球童

最新推荐文章于 2024-07-26 00:55:46 发布

阅读量169

点赞数

分类专栏：笔记文章标签： spring java

本文链接：https://blog.csdn.net/Ther_123/article/details/120834220

版权

笔记专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Spring

1.Spring概念

1.1 Spring框架的概述

概述：

Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring 是一个分层的 JavaSE/EE full-stack(一站式) 轻量级开源的Java EE框架。

IOC：控制反转，把创建对象过程交给Spring进行管理
AOP：面向切面，在不修改源代码的情况下，进行源代码的功能增强

特点：

方便解耦，简化开发
AOP编程的支持
方便程序的测试
方便集成各种优秀的框架
方便进行事务操作
降低API的使用难度

1.2 Hello Spring

文件结构：

在这里插入图片描述

1.首先新建一个maven项目

在这里插入图片描述

2.在maven项目中导入spring依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.9</version>
</dependency>

3.创建一个简单的JavaBean

package com.spring.pojo;

public class User {
    private String name;
    private String id;

    public User() {
    }

    public String getName() {
        return name;
    }

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

    public String getId() {
        return id;
    }

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

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

4.编写xml配置文件beans1.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.spring.pojo.User"></bean>
</beans>

5.编写测试类

package testdemo;

import com.spring.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class testSpring5 {
    @Test
    public void testUser(){
        //1.加载spring的配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
        //2.获取配置创建的对象
        User user = context.getBean("user", User.class);
        user.setId("1");
        user.setName("张三");
        System.out.println(user);

    }
}
//输出结果：
//User{name='张三', id='1'}

2.IoC容器

2.1 IoC底层原理

IoC概述

什么是IoC？

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

控制反转，把对象创建和对象之间的调用过程，交给spring进行管理。
使用IoC的目的：为了降低耦合度

Ioc底层原理

应用的技术：xml解析、工厂模式、反射

底层原理的实现：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lfOOUnbS-1634560662323)(D:/Java/note/image-20211018103242084.png)]

2.2 IoC接口

IoC思想基于 IoC容器完成，IoC容器底层就是对象工厂。
Spring提供IoC容器实现两种方式：（两个接口）
1. **BeanFactory：**IoC容器的最基本实现，是Spring内部使用接口，一般不使用。
  
  加载配置文件的时候不会创建对象，只是在获取（使用）的时候才会创建对象
2. **ApplicationContext：**BeanFactory接口的子接口，提供更多更强大的功能，一般使用ApplicationContext。
  
  加载文件的时候就创建对象。
ApplicationContext接口的实现类

2.3 IoC操作Bean管理

什么是Bean管理？

Bean管理是指两个操作
Spring创建对象
Spring注入属性

Bean管理操作的两种方式

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

2.3.1 基于xml方式创建对象：

在Spring配置文件中，使用bean标签，标签里面添加对应的属性，就可以实现对象创建。

常用的bean标签属性：

<!--配置User对象创建-->
<!--id属性：唯一标识（相当于起别名）-->
<!--class属性：创建对象所在类的全路径-->
<bean id="user" class="com.spring.pojo.User" ></bean>

创建对象的时候，默认执行无参构造，完成对象的创建。

基于xml方式注入属性

DI：依赖注入，就是注入属性

set方式（原始方式）

创建属性和set方法

public class Book {

    //创建属性
    private String bname;

    public String getBname() {
        return bname;
    }
    //创建属性对应的set方法
    public void setBname(String bname) {
        this.bname = bname;
    }
    
}

在spring配置文件中配置对象的创建，配置属性注入。

<!--set方法注入属性-->
<bean id="book" class="com.spring.pojo.Book">
    <!--使用property完成属性注入
        name:属性名称
        value:向属性中注入的值
    -->
    <property name="bname" value="平凡的世界"></property>
</bean>

测试：

@Test
public void testBook(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Book book = context.getBean("book", Book.class);
    System.out.println(book.getBname());
    //平凡的世界
}

通过有参构造

创建属性

创建有参构造

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

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

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

有参构造注入属性

<!--有参数构造器注入属性-->
<bean id="order" class="com.spring.pojo.Order">
    <constructor-arg name="address" value="China"></constructor-arg>
    <constructor-arg name="oName" value="电脑"></constructor-arg>
</bean>

测试

@Test
public void testOrder(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Order order = context.getBean("order", Order.class);
    System.out.println(order);
    //Order{oName='电脑', address='China'}
}

p名称空间注入：简化xml配置方式

添加p名称空间在配置文件中 xmlns:p=“http://www.springframework.org/schema/p”

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

进行属性注入，在bean标签中进行操作

<bean id="book1" class="com.spring.pojo.Book" p:bname="悲惨世界"></bean>

xml注入其他类型属性

向属性中注入null值使用null标签

<!--null值-->
<bean name="book2" class="com.spring.pojo.Book">
    <property name="bname">
        <null/>
    </property>
</bean>

@Test
public void testNull(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Book book = context.getBean("book2", Book.class);
    System.out.println(book.getBname());
    //null
}

向属性中注入特殊符号

<!--属性符号包含特殊符号
    用转义符转义比如：&lt表示< &dt表示>
    用xml中的CDATA
-->
<bean name="book3" class="com.spring.pojo.Book">
    <property name="bname">
        <value>
            <![CDATA[<自在独行>]]>
        </value>
    </property>
</bean>

@Test
public void testCDATA(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
    Book book = context.getBean("book3", Book.class);
    System.out.println(book.getBname());
    //<自在独行>
}

注入属性：外部Bean

创建两个类service类、dao类

在service层中调用dao层

public class UserService {
    //创建UserDAO类型属性，生成set方法，通过调用set方法实现注入
    private UserDAO userDAO;

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    public void add(){
//        //原始方式
//        UserDAO dao = new UserDAOImpl();
//        dao.update();
        System.out.println("service add————————");
        userDAO.update();
    }
}
public interface UserDAO {
    public void update();
}
public class UserDAOImpl implements UserDAO{
    @Override
    public void update() {
        System.out.println("dao update————————");
    }
}

在spring配置文件中进行配置

<!--1.service和dao对象创建-->
<bean id="userService" class="com.spring.service.UserService">
    <!--注入userDao对象
        name属性值：类里面的属性名称
        ref:创建userDao对象bean的属性值
    -->
    <property name="userDAO" ref="userDao"></property>
</bean>

<bean id="userDao" class="com.spring.dao.UserDAOImpl"></bean>

测试：

 @Test
    public void test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
        UserService bean = context.getBean("userService", UserService.class);
        bean.add();
//        service add————————
//        dao update————————
    }

注入属性-内部Bean

一对多关系：部门和员工

<!--内部bean-->
<bean id="emp" class="com.spring.pojo.Emp">
    <property name="ename" value="张三"></property>
    <property name="gender" value="男"></property>
    <property name="dept">
        <bean id="dept" class="com.spring.pojo.Dept">
            <property name="dName" value="管理部"></property>
        </bean>
    </property>
</bean>

public class Dept {
    private String dName;

    public void setdName(String dName) {
        this.dName = dName;
    }
}

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 +
                '}';
    }
}
@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
    Emp emp = context.getBean("emp", Emp.class);
    System.out.println(emp);
    //Emp{ename='张三', gender='男', dept=com.spring.pojo.Dept@2767e23c}
}

注入属性-级联赋值

第一种方法

<!--级联赋值-->
<bean id="emp1" class="com.spring.pojo.Emp">
    <property name="ename" value="张三"></property>
    <property name="gender" value="男"></property>
    <property name="dept" ref="dept1"></property>
</bean>
<bean id="dept1" class="com.spring.pojo.Dept">
    <property name="dName" value="财务部"></property>
</bean>

@Test
public void test2(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
    Emp emp = context.getBean("emp1", Emp.class);
    System.out.println(emp);
    //Emp{ename='张三', gender='男', dept=Dept{dName='财务部'}}
}

第二种方法

<!--级联赋值-->
<bean id="emp1" class="com.spring.pojo.Emp">
    <property name="ename" value="张三"></property>
    <property name="gender" value="男"></property>
    <property name="dept" ref="dept1"></property>
    <property name="dept.dName" value="开发部"></property>
</bean>
<bean id="dept1" class="com.spring.pojo.Dept">
    <property name="dName" value="管理部"></property>
</bean>

xml注入集合属性

数组类型
List集合
Map集合

Set集合

创建类，定义相关类型的属性

public class Stu {
    //数组类型
    private String[] courses;

    //list集合
    private List<String> list;

    //map集合
    private Map<String,String> maps;

    //set集合
    private Set<String> set;

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

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

    public void setMaps(Map<String, String> maps) {
        this.maps = maps;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }
}

在spring配置文件中配置

<!--集合类型属性注入-->
<bean id="stu" class="com.spring.pojo.Stu">
    <!--数组类型属性注入-->
    <property name="courses">
        <array>
            <value>java</value>
            <value>c</value>
            <value>python</value>
        </array>
    </property>
    <!--list类型属性注入-->
    <property name="list">
        <list>
            <value>甲</value>
            <value>乙</value>
            <value>丙</value>
        </list>
    </property>
    <!--Map类型属性注入-->
    <property name="maps">
        <map>
            <entry key="JAVA" value="java"></entry>
            <entry key="PYTHON" value="python"></entry>
        </map>
    </property>
    <!--set类型属性注入-->
    <property name="set">
        <set>
            <value>1</value>
            <value>2</value>
            <value>3</value>
        </set>
    </property>
</bean>

测试

@Test
    public void test1(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
        Stu stu = context.getBean("stu", Stu.class);
        System.out.println(Arrays.toString(stu.getCourses()));
        //遍历list
        stu.getList().forEach(System.out :: println);
        //遍历map
        System.out.println(stu.getMaps());
        //遍历set
        stu.getSet().forEach(System.out :: println);
//        [java, c, python]
//        甲
//        乙
//        丙
//        {JAVA=java, PYTHON=python}
//        1
//        2
//        3
    }

在集合中设置对象类型的值

在list标签中嵌套一个ref标签属性bean的值是对象的bean

把集合注入部分提取出来

在spring中引入名称空间util

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       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">

使用util标签做到提取集合属性注入

<bean id="stu" class="com.spring.pojo.Stu">
    <!--list类型属性注入-->
    <property name="list" ref="list1"></property>
</bean>

<util:list id="list1">
    <value>hello1</value>
    <value>hello2</value>
    <value>hello3</value>
</util:list>

2.3.2 IoC操作Bean管理（FactoryBean）

Spring中有两种类型的Bean一种普通的Bean，另外一种工厂Bean（FactoryBean）

普通Bean：定义什么类型就返回什么类型

FactoryBean：返回类型不一定是定义类型

创建类，让这个类作为工厂Bean实现FactoryBean

实现接口里面的方法，在实现的方法中定义返回的类型

public class MyBean implements FactoryBean<Course>{
    //定义返回的类型
    @Override
    public Course getObject() throws Exception {
        Course course = new Course();
        course.setCourse("abc");
        return course;
    }

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

2.3.3 bean的作用域

spring一般默认属性为单实例
scope属性值
- 默认为singleton：单实例对象
- prototype：多实例对象
```
<bean id="stu" class="com.spring.pojo.Stu" scope="prototype"></bean>
```
- singleton和prototype的区别：singleton在加载配置文件的时候就会生成单实例对象，prototype在调用getBean方法的时候才会创建对象。

2.3.4 bean的生命周期

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean的引用（调用set方法）
调用bean的初始化的方法
得到bean
当容器关闭的时候，调用bean销毁的方法。

测试生命周期：

public class Orders {
    public Orders() {
        System.out.println("1.执行无参构造创建bean实例");
    }

    private String oname;

    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. 执行销毁的方法");
    }

}

<!--init-method：设置初始化执行方法
    destroy-method:设置销毁的方法
-->
<bean id="orders" class="com.spring.bean.Orders" init-method="initMethod" destroy-method="destroyMethod">
   <property name="oname" value="手机"></property>
</bean>

@Test
public void testBean(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
    Orders orders = context.getBean("orders", Orders.class);
    System.out.println("4. 获取到创建bean的实例");
    System.out.println(orders);

    //手动让bean的实例销毁
    context.close();
    //        1.执行无参构造创建bean实例
    //        2. 调用set方法设置值
    //        3. 执行初始化的方法
    //        4. 获取到创建bean的实例
    //        com.spring.bean.Orders@742ff096
    //        5. 执行销毁的方法
}

bean的后置处理：

通过构造器创建bean实例（无参数构造）
为bean的属性设置值和对其他bean的引用（调用set方法）
把bean实例传递bean后置处理器的方法
调用bean的初始化的方法
把bean实例传递bean后置处理器的方法
得到bean
当容器关闭的时候，调用bean销毁的方法。

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;
    }
}

<!--配置后置处理器-->
<!--会为所有的bean添加-->
<bean id="myBeanPost" class="com.spring.bean.MyBeanPost" ></bean>

/*执行结果：
1.执行无参构造创建bean实例
2. 调用set方法设置值
在初始化之前执行的方法
3. 执行初始化的方法
在初始化之后  执行的方法
4. 获取到创建bean的实例
com.spring.bean.Orders@17f9d882
5. 执行销毁的方法
*/

2.3.5 自动装配

自动装配：根据指定装配规则（属性名称或者属性类型），Spring自动将匹配的属性值进行注入。

自动装配过程：

<!--自动装配autowire
    byName：根据属性的名称注入，注入的bean的id的值要跟属性名称一致
    byType：根据属性的类型注入
-->
<bean id="emp" class="com.spring.autowire.Emp" autowire="byName"></bean>
<bean id="dept" class="com.spring.autowire.Dept"></bean>

<bean id="emp" class="com.spring.autowire.Emp" autowire="byType"></bean>
<bean id="dept1" class="com.spring.autowire.Dept"></bean>

2.3.6 外部属性文件

引入依赖
创建配置文件
增加内部空间
引入依赖使用el表达式

<?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">


    <!--直接配置数据库连接池-->
    <!--<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">-->
    <!--    <property name="driverClassName" value="com.mysql.jdbc.driver"></property>-->
    <!--    <property name="url" value="jdbc:mysql://localhost:3306/user"></property>-->
    <!--    <property name="username" value="root"></property>-->
    <!--    <property name="password" value="200011"></property>-->

    <!--</bean>-->
    <!--引入外部属性文件-->
    <context:property-placeholder location="jdbc.properties"/>
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${prop.driverClass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.username}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>
</beans>

2.3.7 IoC基于注解方式管理Bean

注解：代码中的特殊标记 @注解名称（属性名称=属性值…）

创建对象的注解：以下注解的功能是一样的，都用来创建bean实例

@Component
@Service
@Controller
@Repository

基于注解方式实现对象创建

引入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.10</version>
</dependency>

开启组件扫描

<!--开启组件扫描-->
<!--第一种写法，多个包扫描使用逗号隔开-->
<context:component-scan base-package="com.spring.pojo,com.spring.service,com.spring.dao"></context:component-scan>
<!--第二种写法，使用上层目录-->
<context:component-scan base-package="com.spring"></context:component-scan>

注意：

<!--
    use-default-filters="false":表示不使用默认的filter，自己配置filter
-->
<context:component-scan base-package="com.spring" use-default-filters="false">
    <!--
    context:include-filter：设置扫描哪些内容
    -->
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

<!--
    扫描包下的所有内容
    context:exclude-filter:设置哪些内容不进行扫描
-->
<context:component-scan base-package="com.spring">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

创建类，在类上面添加创建对象的注解

package com.spring.service;

import org.springframework.stereotype.Component;

//在注解里面value可以省略不写，默认是类名称首字母小写
@Component(value = "userService")//<bean id="" class="">
public class UserService {
    public void add(){
        System.out.println("service add _____");
    }
}

测试：

public class testDemo1 {
    @Test
    public void testService(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");

        UserService userService = context.getBean("userService", UserService.class);
        userService.add();
//        service add _____
    }
}

基于注解方式实现属性的注入

@AutoWired：根据属性类型进行自动装配
@Qualifier：根据属性名称进行注入（要配合@AutoWired一起使用）
@Resource：可以根据类型注入，也可以根据名称注入
@Value：注入普通类型属性

注入步骤：

创建相应的类并添加注解

@Repository
public class UserDaoImpl implements UserDao{
    @Override
    public void add() {
        System.out.println("dao add+++++++++++++");
    }
}

在service中注入dao对象，添加相关属性，并在属性上面使用注解。

@Service
public class UserService {
    //定义dao类型属性
    //可以不添加set方法
    @Autowired
    private UserDao userDao;

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

根据名称注入：@Qualifier：根据属性名称进行注入（要配合@AutoWired一起使用）

@Service
public class UserService {
    //定义dao类型属性
    //可以不添加set方法
    @Autowired
    //根据名称注入
    @Qualifier(value = "userDaoImpl")
    private UserDao userDao;

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

@Resource：可以根据类型注入，也可以根据名称注入

@Service
public class UserService {
    //根据类型注入
    @Resource(name = "userDaoImpl")//根据名称注入
    private UserDao userDao;

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

@Value：注入普通类型属性

@Service
public class UserService {
    @Value(value = "abc")
    private String name;

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

2.3.8 纯注解开发（完全注解开发）

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

package com.spring.config;

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

@Configuration//作为配置类，替代xml配置文件
@ComponentScan(basePackages = {"com.spring"})
public class SpringConfig {

}

编写测试类

@Test
public void testService2(){
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
    UserService userService = context.getBean("userService", UserService.class);
    userService.add();
}

3.AOP

3.1 概述

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

通俗描述：不通过修改源代码的方式添加新的功能权限。

3.2 AOP底层原理

AOP的底层使用动态代理

有接口的情况下，使用JDK动态代理
- 创建接口实现类的代理对象。增强类的方法
没有接口的情况下，使用CGLIB动态代理
- 创建子类的代理对象，增强类的方法

3.2.1 AOP（JDK动态代理）

使用JDK动态代理，使用Proxy类里面的方法创建代理对象

public interface UserDao {
    public int add(int a,int b);

    public String update(String id);
}

public class UserDaoImpl implements UserDao{

    @Override
    public int add(int a, int b) {
        System.out.println("add方法执行了...");
        return a+b;
    }

    @Override
    public String update(String id) {
        System.out.println("update方法执行了...");
        return id;
    }
}

public class JDKProxy {
    public static void main(String[] args) {
        Class[] interfaces = {UserDao.class};


        UserDao dao = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(new UserDaoImpl()));

        int add = dao.add(1, 2);

        System.out.println(add);
    }
}

//创建代理对象代码
class UserDaoProxy implements InvocationHandler{

    //把创建类的代理对象传进来
    //有参数构造传递
    private Object obj;

    public UserDaoProxy(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;
    }
}

AOP术语

连接点：在一个类中，哪些方法可以被增强，那么这些方法就叫做连接点。
切入点：实际被真正增强的方法，就叫做切入点。
通知（增强）：实际增强的逻辑部分称为通知
- 前置通知
- 后置通知
- 环绕通知
- 异常通知
- 最终通知
切面：把通知应用到切入点的过程。

3.3 AOP操作

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

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

3.3.1 基于AspectJ实现AOP操作

基于xml配置文件实现

基于注解方式实现（常用）

在项目中引入AOP相关依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.3.10</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.9.RELEASE</version>
</dependency>

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.1</version>
</dependency>

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.1</version>
</dependency>

切入点表达式

切入点表达式

作用：知道对哪个类里面的哪个方法进行增强
语法结构：execution([][][权限修饰符] [返回类型] [类全路径] [方法名称] [参数列表])

3.3.2 AOP操作（AspectJ注解）

创建类，在类里面创建方法

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

创建增强类（编写增强逻辑）

在增强的类里面，创建方法，让不同方法代表不同通知类型

//增强的类
public class UserProxy {
    //前置通知
    public void before(){
        System.out.println("before........");
    }
}

进行通知的配置

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

</beans>

使用注解创建User和UserProxy的对象@Component
在增强的类上面添加注解@Aspect

在spring配置文件中开启生成代理对象

<!--开启AspectJ生成代理对象-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

配置不同类型的通知

在增强类的里面，在作为通知方法上面添加通知类型的注解，使用切入点表达式配置

//增强的类
@Component
@Aspect
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void before(){
        System.out.println("before........");
    }
}

测试

//增强的类
@Component
@Aspect
public class UserProxy {
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void before(){
        System.out.println("before........");
    }
    @After(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void after(){
        System.out.println("after.......");
    }
    @AfterReturning(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void afterReturning(){
        System.out.println("afterReturning.......");
    }
    @AfterThrowing(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void afterThrowing(){
        System.out.println("afterThrowing.......");
    }
    //环绕通知
    @Around(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void around(ProceedingJoinPoint proceedingJo) throws Throwable {
        System.out.println("环绕之前.......");

        //被增强的方法执行
        proceedingJo.proceed();

        System.out.println("环绕之后.......");

    }
}

public class TestAop {
    @Test
    public void testAopAnno(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();
        /*
           环绕之前.......
            before........
            add..............
            afterReturning.......
            after.......
            环绕之后.......
        */

    }
}

相同的切入点抽取

//增强的类
@Component
@Aspect
public class UserProxy {
    //相同的切入点抽取
    @Pointcut(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void pointDemo(){
        
    }
    
    //前置通知
    //@Before注解表示作为前置通知
    @Before(value = "pointDemo()")
    public void before(){
        System.out.println("before........");
    }
    @After(value = "pointDemo()")
    public void after(){
        System.out.println("after.......");
    }
    @AfterReturning(value = "pointDemo()")
    public void afterReturning(){
        System.out.println("afterReturning.......");
    }
    @AfterThrowing(value = "pointDemo()")
    public void afterThrowing(){
        System.out.println("afterThrowing.......");
    }
    //环绕通知
    @Around(value = "pointDemo()")
    public void around(ProceedingJoinPoint proceedingJo) throws Throwable {
        System.out.println("环绕之前.......");

        //被增强的方法执行
        proceedingJo.proceed();

        System.out.println("环绕之后.......");

    }
}

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

在增强类上面添加注解@Order（数字类型的值），数字类型值越小，优先级越高

@Component
@Aspect
@Order(1)
public class PersonProxy {
    @Before(value = "execution(* com.spring.aopTest.aopanno.User.add())")
    public void before(){
        System.out.println("Person Before.......");
    }
}

完全注解开发（创建配置类，不需要xml配置文件）

@Configuration
@ComponentScan(basePackages = {"com.spring"})
@EnableAspectJAutoProxy(proxyTargetClass = true)
public class ConfigAop {
}

3.3.3 AOP操作（AspectJ配置文件）

创建两个类，一个增强类，一个被增强类
在spring配置文件中创建两个类对象

在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/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

    <!--创建两个类的对象-->
    <bean id="book" class="com.spring.aopTest.aopXml.Book"></bean>
    <bean id="bookProxy" class="com.spring.aopTest.aopXml.BookProxy"></bean>
    
    <!--配置aop增强-->
    <aop:config>
        <!--切入点-->
        <aop:pointcut id="p" expression="execution(* com.spring.aopTest.aopXml.Book.buy(..))"/>
        
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增强具体作用的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
        
    </aop:config>
    
</beans>

测试

@Test
public void testAopXML(){
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
    Book book = context.getBean("book", Book.class);
    book.buy();

    //        before.........
    //        buy.......
}

安菲尔德球童

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring--01

Spring1.Spring概念1.1 Spring框架的概述概述：Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。任何 Java 应用都可以从 Spring 中受益。Spring 的核心是控制反转（IOC）和面向切面（AOP）。简单来说，Spring 是一个分层的 JavaSE/EE
复制链接

扫一扫

专栏目录