深入浅出 Spring 框架,原来以前的都白学了

Spring框架详解(持续更新) Mybatis Spring SpringMVC详解 阅读详情

1. 为啥要用 Spring

张三是一个编程小白,他每次在 service 层写代码都要自己 new 一堆 Dao 接口的实现类。

public class ProjectServiceImpl implements ProjectService {
    UserDao userDao = new UserDaoImpl();
    ProjectSectionDao projectSessionDao = new ProjectSessionDaoImpl();
    ProjectDao projectDao = new ProjectDaoImpl();
    SupplyDao supplyDao = new SupplyDaoImpl();
    .......   
}

有一天正 new 着对象,张三心想:"我这一个 service 都需要 new 好多 Dao ,那如果有一堆 service ,那我不得花费好长时间?"

"有没有一个工具类或者什么框架能帮我管理这些对象?我只需要配置一下,需要的时候它就能自动帮我 new 个对象出来?"

张三陷入了深深的沉思之中。

张三的室友李四也是一个编程小白。

李四呢想给自己的小项目增加一个功能:记录方法执行的时间。结果他脑子一热竟然给所有的方法都增加了一堆打印方法:

System.out.println("项目开始执行");
// 开始时间
long start = System.currentTimeMillis();

// 业务代码

// 结束时间
long end = System.currentTimeMillis();
// 计算执行时间
System.out.printf("执行时间:%d 毫秒.", (end - start));

过了半个小时,李四终于给项目中所有的方法都复制粘贴上了打印语句。他长舒一口气:"我真是个大聪明!"

张三看了一眼李四的代码,连连鼓掌:"妙啊!咱们宿舍的技术大神!"

旁边的王五实在忍不住了,对张三说:"妙个屁!最近的 Spring 框架课你俩是不是都没去?光顾着打游戏了?我都替你俩答了三次到了!"

李四问王五:"这个Spring 框架学了有用吗?"

王五:"不仅能解决张三说的管理对象的问题,还能帮你解决记录日志的问题。配置完 Spring ,你只需要定义一个切面类,根本不需要在一堆类上面复制粘贴一堆代码。"

张三摸摸后脑勺笑着说:"原来 Spring 框架那么好用,我以后再也不逃课了。我这就去翻课本学习 Spring 框架去。"

2. Spring 简介

Spring 是一个轻量级的 Java 开发框架。Spring 的核心是控制反转(IOC)和面向切面编程(AOP)。

Spring 主要有如下优点:

1.解耦

2.支持面向切面编程

3.便于集成其他框架

3. 环境搭建

1.创建 Maven 项目

File -> New -> Project -> Maven

2.引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.16.RELEASE</version>
    </dependency>
</dependencies>

3.创建接口和实现类

UserService

public interface UserService {
    void print();
}

UserServiceImpl

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

4.创建配置文件

applicationContext.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="userService" class="com.xxl.service.impl.UserServiceImpl"/>
</beans>

5.测试

@Test
public void testSpring(){
    // 1、获取工厂
    ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
    // 2、通过工厂类获得对象
    UserService userService = (UserService)act.getBean("userService");
    // 3.调用方法
    userService.print();
}

测试结果:

4. IOC

4.1 IOC 简介

IOC,全称 Inversion of Control,意思是控制反转。它是 Spring 框架中的一种思想。

控制反转就是将对象的控制权从程序中的代码转移到了 Spring 的工厂,通过 Spring 的工厂完成对象的创建以及赋值。

也就是说之前是我们自己 new 对象、给对象中的成员变量赋值。现在是让 Spring 来帮助我们创建对象、给成员变量赋值。

4.2 Spring 核心内容描述

1.配置文件

Spring 的配置文件可以放到项目中的任意一个地方,也可以随意命名,但是建议使用:applicationContext.xml。

你可以将这个配置文件看成一个装有一堆 bean 标签的容器。

2.bean 标签

Spring 工厂创建的对象,叫做 bean,所以一个 bean 标签代表一个对象。

<bean id="userService" class="com.xxl.service.impl.UserServiceImpl"/>

bean 标签中必须要有 class 属性,它的值是一个类的全限定名(包名+类名)。

除了 class 属性,bean 标签还可以设置 id 、name 、scope属性。

id:

id 必须以字母开头,相当于这个 bean 的身份证号,是唯一的。

如果这个 bean 只使用一次,id 可以省略不写。

如果这个 bean 需要被其他 bean 引用,或者这个 bean 要使用很多次,则必须要有 id 属性。

如果只配置 class 属性,Spring 框架会给每一个 bean 配置一个默认的 id:"全限定名#1"。

例如:

com.xxl.service.impl.UserServiceImpl#1

name:

name 相当于这个 bean 的别名,它可以配置多个,例如:

<bean id="user" name="aa,bb,cc" class="com.xxl.model.User"/>

scope:

scope 属性可以控制简单对象的创建次数,它有两个值:

1.singleton:每次只会创建唯一⼀个简单对象,默认值。

2.prototype:每⼀次都会创建新的对象。

例如:

<bean id="user" class="com.xxl.model.User" scope="singleton"/>

3.ApplicationContext

ApplicationContext 是 Spring 的工厂,主要用来创建对象。

Spring 通过读取配置文件创建工厂。

因为 Spring 的工厂会占用大量内存,所以一个程序一般只会创建一个工厂对象。

4.工厂常用方法

1.根据 id 获取对象

UserService userService = (UserService)act.getBean("userService");

2.根据 id 和类名获取对象

UserService userService = (UserService)act.getBean("userService",UserService.class);

3.只根据类名获取对象

UserService userService = (UserService)act.getBean(UserService.class);

4.获取配置文件中所有 bean 标签的 id 值

String[] beanDefinitionNames = act.getBeanDefinitionNames();
for (String beanDefinitionName : beanDefinitionNames) {
    System.out.println(beanDefinitionName);
}

结果:

5.判断是否存在指定 id 或者 name 的 bean

act.containsBean("userService")

6.判断是否存在指定 id 的 bean,只能用来判断 id

act.containsBeanDefinition("userService")

5.创建对象

Spring 是如何创建对象的呢?

工厂和反射。

首先说下反射,我们可以通过一个类的全限定名获取 Class 对象,然后再通过 Class 实例化一个对象:

Class serviceClass = Class.forName("com.xxl.service.impl.UserServiceImpl");
UserService userService = (UserService)serviceClass.newInstance();

Spring 配置文件中 bean 标签的 id 和类的全限定名一一对应,所以 Spring 工厂的 getBean 方法其实就是先根据 bean 的 id 获取该类的全限定名,然后再利用反射根据类的全限定名创建对象并返回。

4.3 IOC 优点

解耦。

说起解耦之前先说下耦合:耦合是指代码之间的关联性太强,我如果改了这一段代码,可能会影响到一堆代码。

那创建对象哪里有耦合了?其实就是new关键字带来的耦合。

如果你发现一个接口的实现类需要修改,你需要手动改动程序中的代码,比如修改 new 关键字后面的实现类,这样可能会影响到其他的代码。

但是使用了 Spring 之后,我们只需要修改配置文件中 bean 标签的 class 属性对应的类的全限定名,不用修改程序中的代码,这样就做到了解耦。

解耦就是解除不同代码之间的关联性、依赖性。

5. DI

DI 全称 Dependency Injection,意思是依赖注入,它是 IOC 的具体实现。

依赖就是说我需要你,比如 Service 层依赖 Dao 层,注入就是赋值。

依赖注入:使用 Spring 的工厂和配置文件为一个类的成员变量赋值。

没有使用 Spring 的依赖注入我们是这样赋值的:

User user = new User();
user.setName("张三");

如果设置有误,就需要手动修改代码,代码耦合度较高,而依赖注入的出现就是为了解耦。

Spring 的依赖注入包含两种方式:

5.1 set 注入

set 注入:Spring 调用 Set 方法通过配置文件为成员变量赋值。

1.创建对象,为属性添加 set/get 方法

public class User {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

2.修改配置文件

<bean id="user" class="com.xxl.model.User">
  <property name="name" value="知否君" />
  <property name="age" value="18" />
</bean>

3.测试

// 1、获取工厂
ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
// 2、通过工厂类获得对象
User user = (User)act.getBean("user");
System.out.println("姓名:"+user.getName());
System.out.println("性别:"+user.getAge());

测试结果:

从上面的例子可以看出 Set 注入就是在 property 标签中为属性赋值。spring 可以为 JDK 内置的数据类型进行赋值,也可以为用户自定义的数据类型进行赋值。

5.1.1 JDK 内置数据类型

1.基本类型

<property name="name" value="知否君" />
<property name="age" value="18" />

2.List 集合

<property name="phones">
	<list>
		<value>15799999918</value>
		<value>15788888819</value>
		<value>15766666620</value>
	</list>
</property>

3.Set 集合

<property name="phones">
	<set>
		<value>15799999918</value>
		<value>15788888819</value>
		<value>15766666620</value>
	</set>
</property>

4.Map 集合

<property name="mapInfo">
    <map>
        <entry>
            <key><value>name</value></key>
            <value>知否君</value>
        </entry>
        <entry>
            <key><value>age</value></key>
            <value>23</value>
        </entry>
    </map>
</property>

5.数组

<property name="phones">
    <list>
      	<value>15799999918</value>
        <value>15788888819</value>
        <value>15766666620</value>
    </list>
</property>

6.Properites

<property name="prop">
    <props>
        <prop key="key1">value1</prop>
        <prop key="key2">value2</prop>
    </props>
</property>

5.1.2 用户自定义数据类型

1.为成员变量添加 set/get 方法

public class UserServiceImpl implements UserService {
    
    private UserDao userDao;

    public UserDao getUserDao() {
        return userDao;
    }

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

2.bean 标签使用 ref 属性

<bean id="userDao" class="com.xxl.dao.impl.UserDaoImpl" />
<bean id="userService" class="com.xxl.service.impl.UserServiceImpl">
   <property name="userDao" ref="userDao"/>
</bean>

3.测试

@Test
public void testSpring(){
    // 1、获取工厂
    ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
    // 2、通过工厂类获得对象
    UserService userService = (UserService)act.getBean("userService");
    // 3.调用方法
    userService.print();
}

测试结果:

解释:

上面的例子中,因为 userDao 是 userService 的一个成员变量,所以在配置文件中需要使用 property 标签,ref 指向了 userDao 这个对象,然后调用 userDao 的 set 方法为 userDao 赋值。

4.自动注入

我们还可以使用 bean 标签的 autowire 属性为自定义变量自动赋值。当类中引用类型的属性名和 bean 标签的 id 值相同时,我们可以使用 byName。例如:

<bean id="userDao" class="com.xxl.dao.impl.UserDaoImpl" />

<bean id="userService" autowire="byName" class="com.xxl.service.impl.UserServiceImpl" />

当类中引用类型的全限定名和 bean 标签的 class 属性的值相同,或者是子类、实现类,我们可以使用 byType。例如:

<bean id="userDao" class="com.xxl.dao.impl.UserDaoImpl" />

<bean id="userService" autowire="byType" class="com.xxl.service.impl.UserServiceImpl" />

5.2 构造注入

构造注入:Spring 调用构造方法通过配置文件为成员变量赋值。

1.为类添加构造方法

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

2.修改配置文件

在 bean 标签中使用 constructor-arg 标签。

<bean class="com.xxl.model.User">
    <constructor-arg value="张三"/>
    <constructor-arg value="18"/>
</bean>

3.测试

@Test
public void testSpring(){
    // 1、获取工厂
    ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
    // 2、通过工厂类获得对象
    User user= (User)act.getBean(User.class);
    System.out.println("姓名:"+user.getName());
    System.out.println("年龄:"+user.getAge());
}

测试结果:

5.3 注入总结

注入就是通过 Spring 的配置文件为类的成员变量赋值。在实际开发中,我们一般采用 Set 方式为成员变量赋值。

6. Bean 的生命周期

Bean 生命周期指的就是由 Spring 管理的对象从创建到销毁的过程,和人生老病死的过程一样。

它主要分为三个阶段: 创建 --> 初始化 --> 销毁

6.1 创建阶段

Spring 工厂创建对象的方式分两类:

1. singleton 模式

当 scope 属性为 singleton ,创建 Spring 工厂的同时创建所有单例对象。

例如:

新建 User 类:

public class User {
    String name;
    int age;

    public User() {
        System.out.println("调用User的构造方法");
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

spring 配置文件注册 bean :

<bean id="user" class="com.xxl.model.User">
    <property name="name" value="知否君"/>
    <property name="age" value="23"/>
</bean>

测试:

@Test
    public void testSpring(){
        ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
    }

执行结果:

我们发现当创建 Spring 工厂的同时就会调用对象的构造方法。因为 spring 中 bean 默认的 scope 就是 singleton ,所以创建工厂的同时默认就会创建多个单例对象。

如果想修改创建单例对象的方式为获取的时候才创建,只需要在 bean 标签上面添加如下属性:

lazy-init="true"

例如:

<bean id="user" class="com.xxl.model.User" lazy-init="true">
    <property name="name" value="知否君"/>
    <property name="age" value="23"/>
</bean>

2. prototype 模式

只有获取对象的时候才会创建对象。

修改 bean 标签的 scope 属性:

<bean id="user" class="com.xxl.model.User" scope="prototype">
    <property name="name" value="知否君"/>
    <property name="age" value="23"/>
</bean>

测试:

@Test
    public void testSpring(){
        ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
        Object user = act.getBean("user");
        System.out.println(user);
    }

执行结果:

通过上面的例子我们发现只有当执行 getBean() 方法的时候才会调用该类的构造方法。

6.2 初始化阶段

spring 中 bean 的初始化操作指的是在创建对象的时候完成一些附加的功能。bean 的初始化操作有两种实现方式:

1.实现 InitializingBean 接口

public class 类名 implements InitializingBean {
    public void afterPropertiesSet(){
       // 初始化方法操作
    }
}

例如:

public class User implements InitializingBean {
    String name;
    int age;
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

    // 初始化操作
    @Override
    public void afterPropertiesSet(){
            this.name = "张无忌";
            this.age = 30;
    }
}

测试:

@Test
    public void testSpring(){
        ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
        Object user = act.getBean("user");
        System.out.println(user);
    }

执行结果:

2.通过创建普通方法完成初始化

在 User 类中创建一个方法

// 初始化方法
  public void initMethod() {
      this.name = "张无忌";
  }

在配置文件中配置 init-method 属性

<bean id="user" class="com.xxl.model.User" init-method="initMethod" >
    <property name="name" value="知否君"/>
    <property name="age" value="23"/>
</bean>

测试:

@Test
    public void testSpring(){
        ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
        Object user = act.getBean("user");
        System.out.println(user);
    }

执行结果:

我们发现该初始化方法在创建对象之后修改了 user 对象的名字。

总结:

初始化方法修改了注入的值,所以初始化方法一定在注入之后执行。

6.3 销毁阶段

Spring 销毁对象前,会调用对象的销毁方法,完成销毁操作。

Spring 什么时候销毁所创建的对象?当 Spring 工厂关闭时,Spring 工厂会调用我们自定义的销毁方法。

销毁方法的定义有两种方式:

1.实现DisposableBean接口

public class 类名 implements DisposableBean {
    // 销毁操作
    @Override
    public void destroy(){
        // 销毁操作业务
    }
}

2.创建普通方法

在 User 类中创建一个方法

// 销毁方法
  public void destroyMethod() {
     // 销毁操作业务
  }

在配置文件中配置 destroy-method 属性

<bean id="user" class="com.xxl.model.User" destroy-method="destroyMethod">
      <property name="name" value="知否君"/>
      <property name="age" value="23"/>
  </bean>

7. Bean 的后置处理

Spring 工厂创建完对象后如果还想对对象干点别的事情,除了初始化阶段,还可以采用Bean的后置处理。

Bean 的后置处理:对 Spring 工厂创建的对象进行二次加工处理,就是创建完对象后再干点别的事。

Bean 后置处理的流程:

1.实现 BeanPostProcessor 接口

public class BeanProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("后置bean: before 方法");
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("后置bean: after 方法");
        if (bean instanceof User) {
            User user = (User) bean;
            user.setName("亚里士多德");
            return user;
        }
        return bean;
    }
}

2.配置文件添加 bean

<bean id="beanProcessor" class="com.xxl.config.BeanProcessor"/>

3.测试

@Test
    public void testSpring(){
        ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
        Object user = act.getBean("user");
        System.out.println(user);
    }

执行结果:

前面我们学习了对象的初始化方法,那么初始化方法和 Bean 的后置处理的执行顺序是什么?

我们来修改一下 User 类,测试一下:

public class User implements InitializingBean {
    String name;
    int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

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

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

测试执行顺序:

其实在实际开发中,我们很少对 Spring 工厂创建的对象进行初始化操作,一般是采用 Bean 的后置处理的方式来加工对象。

BeanPostProcessor 接口有两个方法,这里简称 before 和 after 方法。

这两个方法都是先获取 Spring 创建的对象,然后再对其加工,加工完成后再交给 Spring。

因为这两个方法的作用一样,所以我们一般采用其中的一个方法,这里建议采用 after 方法。

从上面的例子中我们得到了Spring 操作 bean 的顺序:

8. 代理设计模式

8.1 为啥要用代理设计模式?

咱们先来看一个需求:在所有方法的执行前后输出一段日志。

程序小白可能会这样写:

接口:

public interface CalculateService {
    // 加法
    int add(int a,int b);
    // 减法
    int sub(int a,int b);
}

实现类:

public class CalculateServiceImpl implements CalculateService {
    @Override
    public int add(int a, int b) {
        System.out.println("方法执行前打印");
        int result = a + b;
        System.out.println("方法执行后打印");
        return result;
    }

    @Override
    public int sub(int a, int b) {
        System.out.println("方法执行前打印");
        int result = a - b;
        System.out.println("方法执行后打印");
        return result;
    }
}

但是这样写有 3 个问题:

1.代码混乱:业务代码和非业务代码混在一起,看着太乱了

2.代码重复:如果有多个方法,那就要写一堆输出日志的代码片段,吃力不讨好。

3.代码耦合:如果非业务代码(日志打印)要做修改,那所有相关的业务方法都要改一遍,代码耦合度太高。

那有什么解决办法呢?使用代理。

生活中有关代理的例子无处不在,例如:一些大学可以面向全球招生,所以会衍生很多留学中介,这些中介可以帮学校招生。

所以中介的作用就是帮助雇主做事,有了中介,雇主变得很轻松。而在 java 开发中,也存在这样的代理关系,它的专业术语是代理设计模式。

代理设计模式可以很好解决上面开发中遇到的三个问题,帮助我们简化代码、提高工作效率。

8.2 代理设计模式

代理设计模式:通过代理类为目标类做一些额外(非业务)的功能。

专业名词解释:

1.目标类(原始类):指的是完成业务的核心类,一般指的是 service 层的各种实现类。

2.目标方法(原始方法):目标类中的方法是目标方法(原始方法)。

3.额外功能(附加功能):打印日志等非业务功能。

代理设计模式开发步骤:

(1)代理类和目标类实现相同的接口

(2)代理类中除了要调用目标类的方法实现业务功能,还要实现额外功能。

例如:

// 接口
public interface CalculateService {
  业务方法
}

// 目标类
public CalculateServiceImpl implements CalculateService {
  业务方法
}

// 代理类:要实现目标类相同的接口
public CalculateServiceProxy implements CalculateService {
 // 业务方法
 // 额外功能
}

8.3 静态代理

静态代理:给每一个目标类手动开发一个代理类。

例如:

public interface CalculateService {
   // 加法
  int add(int a,int b);
   // 减法
  int sub(int a,int b);
}
// 目标类
public CalculateServiceImpl implements CalculateService {
   @Override
    public int add(int a, int b) {
        int result = a + b;
        return result;
    }
    @Override
    public int sub(int a, int b) {
        int result = a - b;
        return result;
    }
}
// 代理类:要实现目标类相同的接口
public CalculateServiceProxy implements CalculateService {
  private CalculateService calculateService = new CalculateServiceImpl();
  @Override
    public int add(int a, int b) {
        System.out.println("方法执行前打印");
        int result = calculateService.add(a,b);
        System.out.println("方法执行后打印");
        return result;
    }
    @Override
    public int sub(int a, int b) {
        System.out.println("方法执行前打印");
        int result = calculateService.sub(a,b);
        System.out.println("方法执行后打印");
        return result;
    }
}

通过上面的例子我们发现静态代理也存在很多问题:

1.如果存在很多目标类,我们就要手动创建一堆代理类,太繁琐。

2.代理类中混杂着目标类方法和额外功能,代码耦合度高。

那有没有这样一种代理模式?

  • 1.目标类和代理类互不干扰
  • 2.代码耦合度低,便于维护

有的,动态代理闪亮登场!

8.4 动态代理

动态代理:也是通过代理类为目标类做一些额外的功能,但是不用手动写一堆代理类,而是动态地为目标类创建代理类。

开发流程:

  1. 引入依赖
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.16.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.9.5</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

这里我们主要是引入了 aspectj 这个技术,aspectj 是 spring 社区中非常流行的基于动态代理技术的框架。
  1. 创建目标类和目标方法

接口:

public interface CalculateService {
    // 加法
    int add(int a,int b);
    // 减法
    int sub(int a,int b);
}

实现类(目标类):

public class CalculateServiceImpl implements CalculateService {
     @Override
    public int add(int a, int b) {
        int result = a + b;
        System.out.println("加法操作。。。");
        return result;
    }

    @Override
    public int sub(int a, int b) {
        int result = a - b;
        System.out.println("减法操作。。。");
        return result;
    }
}

3.在 spring 配置文件中注册 bean

<bean id="calculateService"  class="com.xxl.service.impl.CalculateServiceImpl" />

4.实现额外功能

这里我们需要创建一个类实现 MethodInterceptor 接口:

/**
 * @Desc: 动态代理完成非业务功能
 * @Author: 知否技术
 * @date: 下午8:49 2022/5/4
 */
public class PrintLog implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation methodInvocation) throws Throwable {
        System.out.println("在目标方法执行之前打印。。。。。");
        // 执行目标方法
        Object object = methodInvocation.proceed();
        System.out.println("在目标方法执行之后打印。。。。。");
        return object;
    }
}

5.注册完成额外功能的 bean

<bean id="printLog" class="com.xxl.aop.PrintLog" />
  1. 定义切入点
<!--切入点:给哪些方法加入额外功能-->
<aop:config>
  <aop:pointcut id="pc" expression="execution(* * (..))"/>
</aop:config>
  1. 组装切入点和额外功能
<!--切入点:给哪些方法加入额外功能-->
<aop:config>
  <aop:pointcut id="pc" expression="execution(* * (..))"/>
  <aop:advisor advice-ref="printLog" pointcut-ref="pc"/>
</aop:config>

8.测试

@Test
  public void testSpring() {
      // 1、获取工厂
      ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
      // 2、通过工厂类获得对象
      CalculateService calculateService = (CalculateService) act.getBean("calculateService");
      // 3.调用方法
      int result = calculateService.add(1, 2);
      System.out.println("result:" + result);
  }

讲解:

1.上面的例子中我们定义了一个 PrintLog 打印日志的类,并实现了 MethodInterceptor 接口的 invoke 方法。invoke 方法里面实现了在目标方法执行前后打印日志的功能。

2.invoke 方法的返回值就是原始方法的返回值,上个例子中的原始方法就是 add 方法。

3.aop:config 这个标签用来配置切入点和额外功能。 上面例子中额外功能就是在要执行的方法前后打印日志,而切入点就是额外功能要作用的位置:比如某些类上或者某些方法上。

4.execution(* * (..)) 是切入点表达式,表示作用在所有类的所有方法上,这个后面会讲。

5.上面的例子表示:你无论执行哪个方法,这个方法的前面和后面都会打印一段日志。

8.5 动态代理实现原理

我们通过 spring 的工厂获取的对象,其实是通过动态代理技术创建的代理类。那这个代理类在哪里?

当程序运行的时候,spring 框架通过动态字节码技术在 JVM 内存中为目标类创建代理类。当程序运行结束的时候,这个代理类就会随之消亡。

所以使用动态代理不需要手动创建多个代理类。

9. AOP

9.1 AOP 概念

AOP: 全称 Producer Oriented Programing,即面向切面编程。

那啥是面向切面编程?其实说白了还是 Spring 的动态代理,通过代理类为原始类增加一些 额外功能(例如打印等)。

那啥是切面?

切面 = 切入点 + 额外功能。

切入点:额外功能作用的位置,在哪些类哪些方法上。

额外功能作用在不同的类上面,我们都知道点连接起来构成面,所以不同的切入点连接起来构成了切面,这个切面就像刀切西瓜一样切在不同的类上面,所以额外功能就对这些类中的方法起了作用。

9.2 AOP 底层实现原理

AOP 的底层还是使用 Spring 的动态代理技术创建代理类对象。

动态代理的方式分为两种:

  • 基于接口实现动态代理: JDK 动态代理
  • 基于继承实现动态代理:Cglib 动态代理

9.2.1 JDK 动态代理

创建代理对象的三个元素:

  • 1.原始对象
  • 2.额外功能
  • 3.原始对象实现的接口

代码格式:

Proxy.newPorxyInstance(classloader,interfaces,invocationHandler)

讲解:

(1)classloader:叫做类加载器,它可以用来创建代理对象。

创建方式:

类.class.getClassLOader()

(2)interfaces:原始对象实现的接口

创建方式

接口.getClass().getInterfaces()

(3)invocationHandler:额外功能

创建方式:

InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("---- 方法执行前打印 ----");
                // 执行原始方法
                Object ret = method.invoke(caculateService, args);
                System.out.println("---- 方法执行后打印 ----");
                return ret;
            }
        };

完整代码:

@Test
public void testJDKProxy() {
    // 1. 原始对象
    CalculateService calculateService = new CalculateServiceImpl();

    // 2. JDK 动态代理:包含额外功能
    InvocationHandler handler = new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("---- 方法执行前打印 ----");
            // 执行原始方法
            Object result = method.invoke(calculateService, args);
            System.out.println("---- 方法执行后打印 ----");
            return result;
        }
    };
    // 3. 代理类
    CalculateService calService = (CalculateService) Proxy.
            newProxyInstance(CalculateService.class.getClassLoader(),
                    calculateService.getClass().getInterfaces(),
                    handler);
    // 4. 执行方法
    int result = calService.add(1, 2);
    System.out.println("result:" + result);
}

测试结果:

9.2.2 Cglib 动态代理

CGlib 创建动态代理的原理:原始类作为父类,代理类作为子类,通过继承关系创建代理类。

代码格式:

Enhancer enhancer = new Enhancer();
enhancer.setClassLoader(classLoader);
enhancer.setSuperclass(calculateService);
enhancer.setCallback(interceptor);

讲解:

(1)classLoader:类加载器(了解即可)

(2)Superclass:父类,就是原始类

(3)interceptor:额外功能

MethodInterceptor interceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            System.out.println("---- 方法执行前打印 ----");
            // 执行原始方法
            Object result = method.invoke(calculateService, args);
            System.out.println("---- 方法执行后打印 ----");
            return result;
            }
        };

完整代码:

@Test
    public void testCglibProxy() {
        // 1. 原始对象
        CalculateService calculateService = new CalculateServiceImpl();

        // 2. Cglib 动态代理:包含额外功能
        MethodInterceptor interceptor = new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                System.out.println("---- 方法执行前打印 ----");
                // 执行原始方法
                Object result = method.invoke(calculateService, args);
                System.out.println("---- 方法执行后打印 ----");
                return result;
            }
        };

        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(CalculateService.class.getClassLoader());
        enhancer.setSuperclass(calculateService.getClass());
        enhancer.setCallback(interceptor);

        // 3. 创建代理类
        CalculateService calService = (CalculateService)enhancer.create();
        // 4. 执行方法
        int result = calService.add(3, 4);
        System.out.println("result:" + result);
    }

执行结果:

9.2.3 Spring 如何创建代理对象?

Spring 是如何为原始对象创建目标对象的呢?是通过 BeanPostProcessor。

前面我们讲过 BeanPostProcessor 可以对对象进行二次加工,所以可以用来创建代理对象。

Spring 创建代理对象的流程:

  1. 实现 BeanPostProcessor 接口
/**
 * @Desc: 后置bean创建代理对象
 * @Author: 知否技术
 * @date: 上午11:59 2022/5/5
 */
public class ProxyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {

        InvocationHandler handler = (proxy, method, args) -> {
            System.out.println("--- 方法执行前打印6666666---");
            Object ret = method.invoke(bean, args);
            System.out.println("--- 方法执行后打印7777777---");
            return ret;
        };
        return Proxy.newProxyInstance(ProxyBeanPostProcessor.class.getClassLoader(), bean.getClass().getInterfaces(), handler);
    }
}
  1. 注册 bean
<bean id="calculateService"  class="com.xxl.service.impl.CalculateServiceImpl" />
<bean id="proxyBeanPostProcessor" class="com.xxl.aop.ProxyBeanPostProcessor"/>
  1. 测试
@Test
    public void testSpring() {
        // 1、获取工厂
        ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
        // 2、通过工厂类获得对象
        CalculateService calculateService = (CalculateService) act.getBean("calculateService");
        // 3.调用方法
        int result = calculateService.sub(7, 2);
        System.out.println("result:" + result);
    }

9.3 基于注解开发 AOP

开发流程:

  1. 开发切面类
@Aspect
public class TestAspect {

    // 前置通知:方法执行前添加额外功能
    @Before("execution(* *(..))")
    public void beforePrint(){
        System.out.println("------before: 方法执行前打印~");
    }
    
    //后置通知: 方法执行后添加额外功能
    @After("execution(* *(..))")
    public void afterPrint(){
        System.out.println("------after: 方法执行前打印~");
    }

    // 环绕通知:方法执行前后添加额外功能
    @Around("execution(* *(..))")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("方法执行前打印~");
        Object result = joinPoint.proceed();
        System.out.println("方法执行后打印~");
        return result;
    }
}
  1. 配置切面类和扫描注解
<bean id="testMyAspect"  class="com.xxl.aop.TestAspect" />
<!-- 扫描 aop 相关注解-->
<aop:aspectj-autoproxy/>

  1. 测试
@Test
  public void testSpring() {
      // 1、获取工厂
      ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
      // 2、通过工厂类获得对象
      calculateService calculateService = (CalculateService) act.getBean("calculateService");
      // 3.调用方法
      int result = calculateService.add(100, 1);
      System.out.println("result:" + result);
  }

讲解:

1.我们新建了一个 TestMyAspect 类,然后添加 @Aspect 注解,表示这是一个切面类,专门用来完成非业务功能的。

2.在这个类中,我们创建了三个方法,其中 @Before 注解标注的方法表示在目标方法操作前执行。@After 注解标注的方法表示在目标方法操作后执行。@Around 注解标注的方法表示在目标方法操作前后执行。

3.在实际开发中一般使用 @Around 注解标注的方法完成非业务功能。

4.我们新建了这个切面类,但是 spring 不知道啊,所以需要在 Spring 的配置文件中注册一下 bean。

5.现在 Spring 工厂能够管理这个类了,但是 Spring 不知道他是切面类啊!所以需要配置一下扫描注解的标签。

6.然后通过 Spring 获取创建的类,我们获取的其实是 Spring 通过后置 Bean 加工后的代理类。

切入点复用

我们可以在切面类中定义⼀个方法,方法上面标注 @Pointcut 注解。 然后就可以重复使用切入点表达式了:

@Aspect
public class TestAspect {

    @Pointcut("execution(* *(..))")
    public void myPointcut() {}
    
    // 环绕通知:方法执行前后添加额外功能
    @Around(value = "myPointcut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("方法执行前打印~");
        Object result = joinPoint.proceed();
        System.out.println("方法执行后打印~");
        return result;
    }
}

9.4 切入点表达式

切入点:额外功能加入的位置。

<aop:pointcut id="pc" expression="execution(* * (..))"/>
复制代码
  • execution():切入点函数
  • (* * (..)):切入点表达式
public int add(int a, int b)
   *        * (..)

第一个 * 表示方法的修饰符和返回值 第二个 * 是方法名 .. 表示方法中的参数

1.(包.类.方法)切入点:

修饰符-返回值  包.类.方法(参数)

expression="execution(* com.xxl.service.caculateServiceImpl.add(..))"

2.指定切入点为某个包下的所有类中的所有方法:

修饰符-返回值  包.类.方法(参数)

expression="execution(* com.xxl.service.*.*(..))"

3.@annotation

作用:用于匹配当前执行方法持有指定注解的方法,并为之加入额外的功能。

例如我们自定义了一个注解:NoToken

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NoToken {
}

方法中添加自定义注解:

@Override
@NoToken
public int add(int a, int b) {
    int result = a + b;
    System.out.println("加法操作。。。");
    return result;
}

然后我们要为包含 NoToken 注解的方法加入额外功能:

@Aspect
public class TestAspect {
   // 环绕通知:方法执行前后添加额外功能
    @Around("@annotation(com.xxl.annotion.NoToken)")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("包含 NoToken 注解--------------");
        Object result = joinPoint.proceed();
        return result;
    }
}

测试:

@Test
public void testSpring() {
    // 1、获取工厂
    ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
    // 2、通过工厂类获得对象
    CalculateService calculateService = (CalculateService) act.getBean("calculateService");
    // 3.调用方法
    int result1 = calculateService.add(99, 1);
    System.out.println("-----------------------");
    int result2 = calculateService.sub(99, 1);
    System.out.println("result1:" + result1);
    System.out.println("result2:" + result2);
}

10. Spring 相关注解

在讲注解之前我们先看一下啥是注解。

代码格式:@英文单词,例如:

作用位置:常用在类上或者方法上

用处:简化代码、完成某些功能

所以 Spring 引入注解也是为了简化我们的代码,通过使用简单的注解完成一些功能。

10.1 创建对象相关注解

我们前面在学 IOC 的时候知道如果想让 Spring 创建对象,必须要在配置文件中写 bean 标签。

<bean id="calculateService"  class="com.xxl.service.impl.CalculateServiceImpl" />
<bean id="proxyBeanPostProcessor" class="com.xxl.aop.ProxyBeanPostProcessor"/>
<bean id="testMyAspect"  class="com.xxl.aop.TestAspect" />
......

可是如果想让 Spring 管理一堆对象,我们就要写一堆 bean 标签。所以 Spring 为了简化代码,提供了一些与创建对象相关的注解。

10.1.1 @Component

作用:替换 bean 标签,用来创建对象。就是在类上面加了这个注解,就不用在配置文件上写 bean 标签了。

位置:类上面

id 属性:默认首单词首字母小写。

// id 属性:默认首单词首字母小写。
@Component("user")
public class User{

}

10.1.2 @Component 衍生注解

我们在开发程序的时候一般会将程序分层,例如分为控制层(controller),业务层(service),持久层(dao)。

但是 @Component 注解并不能区分这些类属于那些层,所以 Spring 提供了以下衍生注解:

1.@Controller:表示创建控制器对象

@Controller
public class UserController {
    
}

2.@Service:表示创建业务层对象

@Service
public class UserServiceImpl implements UserService {

}

3.@Repository:表示创建持久层对象

@Repository
public class UserDaoImpl implements UserDao {

}
这三个注解的作用和 @Component 的作用一样,都是用来创建对象。

10.1.3 @Scope

我们知道 Spring 工厂创建的对象默认都是单例的,也就是 bean 标签中 scope 属性默认是 singleton。

@Scope 注解可以用来修改创建对象的 scope 属性。

默认:也就是说你不写 @Scope 注解,默认就是 singleton,所以可以省略。

@Component
// 可以省略不写
@Scope("singleton")
public class User {
    
}

修改多例:

@Component
@Scope("prototype")
public class User {
    
}

10.1.4 生命周期相关注解

1.@PostConstruct

初始化方法注解,作用在方法上。用来替换 bean 标签的 init-method 属性。

例如:

@Component
public class User {
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                '}';
    }
    // 初始化方法
    @PostConstruct
    public void init(){
        this.name = "王小波";
    }
}

测试:

@Test
public void testSpring() {
    // 1、获取工厂
    ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
    // 2、通过工厂类获得对象
    User user = (User) act.getBean("user");
    System.out.println(user);
}

报错了!这是为什么?

我们先看报错内容:

No bean named 'user'

也就是说找不到这个对象。我们虽然加了 @Component 注解,但是 Spring 不知道啊,所以需要在 Spring 的配置文件中配置注解扫描:

<context:component-scan base-package="com.xxl"/>

base-package: 添加注解的类所在的包位置。

配置了注解扫描,当程序启动的时候 Spring 会先扫描一下相关的注解,这些注解才会生效。

就比如你去快递驿站拿快递,你看到了自己的快递然后对快递小哥说:"这我的快递我拿走了啊。"但是人家小哥无法确认是你的啊!所以他需要用扫码枪扫一下才能出货!

我们配置注解扫描之后再次测试:

2.@PreDestory(了解即可)

销毁方法注解,作用在方法上。用来替换 bean 标签的 destory-method 属性。

10.2 注入相关注解

10.2.1 @Autowired

我们之前学 DI 的时候知道:注入就是赋值。

@Autowired 主要是为自定义的类型赋值,例如 service、dao 层的各种类。

@Controller
public class UserController {

    @Autowired
    private UserService userService;
}
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;
}

@Autowired 是基于类型进行注入,所注入对象的类型必须和目标 变量类型相同或者是他的子类、实现类。

如果想基于名字注入,可以和 @Qualifier 注解连用:

@Autowired
@Qualifier("orderDAOImpl")
private OrderDAO orderDAO;

10.2.2 @Resource

@Resource 注解是 JAVAEE 规范中提供的注解,他和 @Autowired 注解的作用一样, 但是他是基于名字进行注入:

@Resource("orderDAOImpl")
private OrderDAO orderDAO;

在实际开发中,用 @Autowired 注解比较多一点。

10.2.3 案例

Product 类

@Component
public class Product {

    private  String productName;

    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }

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

    @PostConstruct
    public void init(){
        this.productName = "西瓜";
    }
}

User 类:

@Component
public class User {
    private String name;

    @Autowired
    private Product product;

    public String getName() {
        return name;
    }

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

    public Product getProduct() {
        return product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    @PostConstruct
    public void init(){
        this.name = "小明";
    }

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

测试:

@Test
public void testSpring() {
    // 1、获取工厂
    ApplicationContext act = new ClassPathXmlApplicationContext("/applicationContext.xml");
    // 2、通过工厂类获得对象
    User user = (User) act.getBean("user");
    System.out.println(user);
}

10.3 Spring 配置文件相关注解

10.3.1 @Configuration

@Configuration 注解用于替换 xml 配置文件。

@Configuration
public class SpringConfig {
    
}

意思就是说你在一个类上面加一个 @Configuration 注解,这个类就可以看成 Spring 的配置类,你就不用再写 xml 文件了。

我们之前是根据 xml 文件创建 Spring 的工厂,那怎样根据配置类创建工厂呢?

有两种方式:

方式一:根据类.class

ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

方式二:根据配置类所在的路径

ApplicationContext ctx = new AnnotationConfigApplicationContext("com.xxl");

10.3.2 @Bean

@Bean 注解也是用来创建对象的,相当于spring 配置文件中的 bean 标签。

@Configuration
public class SpringConfig {

    @Bean
    public Product getProduct(){
        return new Product();
    }
}

自定义 id 值:

@Configuration
public class SpringConfig {

    @Bean("product")
    public Product getProduct(){
        return new Product();
    }
}

不过在实际开发中我们一般会用 @Bean 注解创建一些复杂的对象,例如 Redis、MQ 等一些组件对象。

@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(factory);
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        redisTemplate.setValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.setHashKeySerializer(stringRedisSerializer);
        redisTemplate.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

10.3.3 @ComponentScan

@ComponentScan 注解相当于 xml 配置文件中的注解扫描标签:

<context:component-scan base-package="com.xxl"/>

作用:用来扫描@Component 等相关注解

属性:

basePackages:注解所在的包路径

例如:

@Configuration
@ComponentScan(basePackages = "com.xxl")
public class SpringConfig {
}

11. 注解小案例

1.User 类

@Component
public class User {
    private String name;

    @Autowired
    private Product product;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Product getProduct() {
        return product;
    }
    public void setProduct(Product product) {
        this.product = product;
    }

    @PostConstruct
    public void init(){
        this.name = "渣渣辉";
    }

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

2.Product 类

@Component
public class Product {
    private  String productName;
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    @Override
    public String toString() {
        return "Product{" +
                "productName='" + productName + '\'' +
                '}';
    }
}

3.配置类:

@Configuration
@ComponentScan(basePackages = "com.xxl")
public class SpringConfig {

    @Bean
    public Product product() {
        Product product = new Product();
        product.setProductName("草莓味的番茄");
        return product;
    }
}

4.测试

@Test
public void testSpring() {
    // 1、获取工厂
    ApplicationContext act = new AnnotationConfigApplicationContext(SpringConfig.class);
    // 2、通过工厂类获得对象
    User user = (User) act.getBean("user");
    System.out.println(user);
}
Java必修课——Spring框架 Spring是轻量级的开源的JAVAEE框架Spring可以解决企业应用开发的复杂性Spring有两个核心部分:IOC和AopIOC:控制反转,把创建对象的过程交个Spring进行管理Aop:面向切面,不修改源代码进行功能增强Spring特点方便解耦,简化开发Aop编程支持方便程序测试方便和其他框架进行整合方便进行事务操作降低API的使用难度IOC容器IOC底层原理IOC接口(BeanFactory)IOC操作Bean管理(基于XML)IOC操作Bean管理(基于注解) 阅读详情

相关推荐

Spring核心框架完全指南 - 基础知识全解析

《Spring核心框架完全指南》摘要 本文全面解析Spring框架的核心知识点,涵盖IoC容器、AOP编程、Bean管理等核心技术。主要内容包括:1)IoC容器实现对象创建和依赖管理,通过构造器、Setter和字段注入三种方式;2)Bean生命周期管理,包括初始化/销毁方法和作用域控制;3)AOP编程实现日志、权限等横切关注点的统一处理;4)Spring注解体系详解和资源管理机制;5)事件驱动模型实现组件间松耦合通信;6)SpEL表达式语言的应用。文章通过具体代码示例和实际应用场景,系统性地介绍了如何利用S

weixin_51040479的博客 1205

spring框架--全面详解(学习笔记)

由 Spring IoC 容器管理的对象称为 Bean,Bean 根据 Spring 配置文件中的信息创建。可以把 Spring IoC 容器看作是一个大工厂,Bean 相当于工厂的产品,如果希望这个大工厂生产和管理 Bean,则需要告诉容器需要哪些 Bean,以及需要哪种方式装配 Bean。Spring 配置文件支持两种格式,即 XML 文件格式和 Properties 文件格式。

swy2560666141的博客 1万+

群晖NAS下docker安装MySql

本文将一步一步讲解如何在群晖NAS的docker中启用一个MySQL容器 , 算是初学者对问题解决的一个记录.

qq_46375248的博客 5980

Spring框架详解

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

m0_54853420的博客 2376

Unity URP项目里Post Processing死活没效果?别慌,这5个坑我帮你踩过了

本文详细解析了Unity URP项目中Post Processing效果失效的五大常见问题,包括渲染管线配置冲突、Volume作用域误判、摄像机参数漏配、Layer层级冲突和Profile引用异常。通过实际项目案例和代码示例,提供专业级解决方案,帮助开发者快速排查并修复后处理效果不生效的问题。

weixin_33721427的博客 334

如何使用ArcGIS Pro制作带基底三维地图

点击运行生成范围线,因为之前对高程进行了夸大,导致生成的范围线和地形边缘不重合,我们打开范围线的图层属性,选择高程选项卡,要素位于选择地面上,如下图所示。目前制作的三维地图下面是空的一片,现在添加一个基底,在工具箱内点击“3D Analyst工具\栅格\转换\栅格范围”,调用栅格范围工具,如下图所示。打开ArcGIS Pro,新建一个局部场景,在高程表面下,地面上点击右键,选择添加高程源图层,将需要制作三维地图的DEM数据加载进来,如下图所示。在要素图层菜单内,类型选择绝对高度,如下图所示。

3979

深入浅出 Spring 框架,原来以前的都白学了!

Spring 是一个轻量级的 Java 开发框架。Spring 的核心是控制反转(IOC)和面向切面编程(AOP)。Spring 主要有如下优点:1.解耦2.支持面向切面编程3.便于集成其他框架IOC,全称 Inversion of Control,意思是控制反转。它是 Spring 框架中的一种思想。控制反转就是将对象的控制权从程序中的代码转移到了 Spring 的工厂,通过 Spring 的工厂完成对象的创建以及赋值。也就是说之前是我们自己 new 对象、给对象中的成员变量赋值。

jcc4261的博客 1106

Windows域账户无管理员权限也能装软件?3步搞定UAC设置(附安全提醒)

本文探讨了在Windows域环境中,如何通过配置用户账户控制(UAC)实现临时提权,让无管理员权限的域账户也能安装软件。文章详细介绍了三步走策略:临时加入本地管理员组、调整UAC行为以及至关重要的权限回收,并提供了脚本化部署方案与安全实践指南,旨在平衡企业IT管理的效率与安全。

fox11的博客 761

【Java学习经历系列-3】干货 | java学习六个阶段的经验分享

【写在前面】正在java门前一头雾水,焦灼徘徊的你是不是还是没有头绪、不知如何下手?快来看看过来人总结的java学习的六个阶段,希望对你有所帮助… 认识Java是在去年,当时工作是在工地上搞机械管理的,日子轻松,收入也还行,却也无聊,每天就是循环的重复着.当时觉得,难道我就这样子在工地一辈子了,那大学都白读了.所以,那会儿就在网上为自己寻找一个方向.当时看到网上说,程序员工资挺好的,除了每天跟...

weixin_44241825的博客 267

ABAP 7.40+新语法实战:用VALUE和REDUCE五分钟搞定复杂内表统计

本文详细介绍了ABAP 7.40+新语法中的VALUE和REDUCE操作符,如何高效处理复杂内表统计任务。通过实战案例展示,这些新语法能将代码量减少70%以上,显著提升开发效率和可读性,特别适合大数据量下的销售数据分析、分组统计等场景。

weixin_27219587的博客 207

别再手动拷贝文件了!用Keil MDK的Pack Installer一键搞定STM32上的RT-Thread Nano移植

本文详细介绍了如何使用Keil MDK的Pack Installer一键快速移植RT-Thread Nano到STM32项目,告别繁琐的手动拷贝和配置过程。通过自动化版本管理和依赖处理,移植时间从47分钟缩短至3分钟,大幅提升开发效率。文章还提供了实战步骤、高级配置技巧和常见问题解决方案,帮助开发者轻松实现RTOS集成。

weixin_29194817的博客 365

干货|Java六个阶段学习总结(一定要看 对 一定)

Java六个阶段学习总结 认识Java是在去年,当时工作是在工地上搞机械管理的,日子轻松,收入也还行,却也无聊,每天就是循环的重复着.当时觉得,难道我就这样子在工地一辈子了,那大学都白读了.所以,那会儿就在网上为自己寻找一个方向.当时看到网上说,程序员工资挺好的,除了每天跟代码打交道.当时,感觉这完全就是为我量身定制啊,我自己也不喜欢跟人有太多交流,给任务写代码就行,多么完美的一件事.然后我决...

wanghao112956的博客 390

大样本EEG公共数据集汇总

描述: OpenNeuro平台包含多个认知障碍相关的EEG数据集,例如针对轻度认知障碍(MCI)或阿尔茨海默病(AD)的研究。描述: 天普大学医院EEG语料库包含大量临床EEG记录,可通过元数据筛选出与认知障碍相关的片段(如诊断标签包含dementia或MCI)。描述: ADNI主要提供多模态神经影像数据(MRI/PET),但部分合作研究整合了EEG数据。样本量: 部分数据集包含100+被试(例如结合MRI与EEG的多模态数据)。样本量:30,000+ EEG记录(持续更新,全球最大临床EEG数据库)。

谁人打的太极拳的博客 1765

Spring框架

spring框架:负责宏观调控,负责整合其他的第三方的框架 IOC介绍 IOC是一种控制反转的设计思想,由spring容器管理对象的生命周期,降低代码的耦合性。 将所有的对象都交给spring容器管理,容器负责对象的注入 DI介绍:Dependency Injection 依赖注入 spring容器替你管理一系列需要的类,前提是你需要将这些类表示交给容器进行管理才可,然后在你需要的时候不用自己去定义,容器就会自动帮你进行实例化 实现IOC思想需要DI进行注入。 注入的方式最常用的就是@A...

Mr_Jin的博客 4666

SAP 小结

关于SAP 开发的实习就要告一段落了,从刚开始接触,到现在已经6个月了,想要很简要的把自己对SAP的理解写出来,便于以后查阅(不定期更新)。 1. 什么是SAP? 广义的SAP,可以指代SAP公司以及SAP的各种产品,它的意义要在特定语境下才能确定。一般我们所说的SAP特指SAP ERP。 SAP ERP(enterprise resource planning)是一个企业信息系统。通过这个系

Remy的博客 1958

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

科普文:深入理解Spring框架

Spring 是一个开源的轻量级 Java 开发框架,它通过 DI (Dependency Injection) 和 AOP (Aspect-Oriented Programming) 提供了简单的编程模型,帮助开发者构建健壮的、可测试的企业级应用程序。Spring 框架为现代基于 java 的企业应用程序提供了一个全面的编程和配置模型——在任何类型的部署平台上。 Spring 的特点包括模块化、灵活性、高度可测试性和一组丰富的 API。它几乎适用于所有的 Java 应用,包括后端服务、微服务

为无为,事无事,味无味。 2649

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

Spring开发框架

Spring是现在为流行的技术开发框架,也是所有企业开发之中必定要使用的开发框架,使用Spring可以有效的避免代码耦合性问题,也可以方便的进行各种开发资源的整合处理。在Spring框架中其核心组成为DI(依赖注入)与AOP(面向切面编程),而基于这两种处理机制可以有效的避免“硬”编码所带来的耦合问题,从而让所有的开发可以以配置或注解的形式执行,这样即方便修改又解决了类的继承限制问题。官方QQ群:612148723。

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

Spring-全面详解(基础知识)

Spring-全面详解(基础知识)入门级 持续更新中 Spring5框架 内容介绍: 1.Spring概念 2.IOC容器 3.Aop 4.JDBCTEmplate 5.事物管理 6.Spring5新特性

m0_63324772的博客 2万+

spring框架简介

Spring的英文翻译为春天,可以说是给Java程序员带来了春天,因为它极大的简化了开发。我得出一个公式:Spring = 春天 = Java程序员的春天 = 简化开发。最后的简化开发正是Spring框架带来的最大好处。Spring是一个开放源代码的设计层面框架,它是于2003 年兴起的一个轻量级的Java 开发框架。由Rod Johnson创建,其前身为Interface21框架,后改为了Spring并且正式发布。Spring是为了解决企业应用开发的复杂性而创建的。

qq_69907434的博客 2405

Spring框架的全面详解(个人学习总结)

本文是笔者在学习和工作中使用Sping框架时所得出的一些个人理解以及学习总结,涉及到了Spring框架的两大核心技术点IOC与AOP的讲解,Spring框架中的设计模式讲解等一系列技术,本文将采用文字与代码结合的方式讲解,以此来提高大家的理解程度。

2301_77760397的博客 3396
上一篇: 八位阿里大佬耗时三年总结出Java面试复盘手册!带你实现逆风翻盘
下一篇: 阿里为何禁止在对象中使用基本数据类型
Java佳佳
博客等级 码龄4年 216粉丝 286原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值