Spring

最新推荐文章于 2025-07-30 16:11:48 发布

Aaaaazdy

最新推荐文章于 2025-07-30 16:11:48 发布

阅读量370

点赞数

CC 4.0 BY-SA版权

分类专栏： java 文章标签： spring java-ee java

本文链接：https://blog.youkuaiyun.com/weixin_46065591/article/details/122083732

java 专栏收录该内容

6 篇文章

订阅专栏

Spring

EE开发可分成三层架构，针对JavaEE的三层结构，每一层Spring都提供了不同的解决技术。

在这里插入图片描述

Spring的核心有两部分：

IoC：即控制反转。举例来说，之前，有一个类，我们想要调用类里面的方法（不是静态方法），就要创建该类的对象，使用对象调用方法来实现。但对于Spring来说，Spring创建对象的过程，不是在代码里面实现的，而是交给Spring来进行配置实现的；
AOP：即面向切面编程。

IoC

IoC即Inversion of Control，反应过来就是控制反转。控制反转指的就是将对象的创建权反转给（交给）了Spring，其作用是实现了程序的解耦合。也可这样解释：获取对象的方式变了，对象创建的控制权不是"使用者"，而是"框架"或者"容器"。用更通俗的话来说，IoC就是指对象的创建，并不是在代码中用new操作new出来的，而是通过Spring进行配置创建的。

Spring的IoC的底层实现原理

这里先给出结论：Spring的IoC的底层实现原理是工厂设计模式+反射+XML配置文件。 就拿持久层（也即dao层，data access object，数据访问对象）的开发来说，官方推荐做法是先创建一个接口，然后再创建接口对应的实现类。所以，可以借dao层的开发为例来证明Spring的IoC的底层实现原理就是工厂设计模式+反射+XML配置文件。

首先，创建一个Userdao接口

public interface UserDao {
	public void add();
}

然后，再创建Userdao接口的一个实现类（UserDaoImpl.java）

public class UserDaoImpl implements UserDao {
    public void add() {
	    balabala......
    }
}

接着，我们在service层中调用dao层，核心代码如下：

// 接口 实例变量 = new 实现类
UserDao dao = new UserDaoImpl();
dao.add();

这时我们便可发现一个缺点：service层和dao层耦合度太高了，即接口和实现类有耦合（它俩之间的联系过于紧密），一旦切换底层实现类，那么就需要修改源代码，这真的不是一个好的程序设计

解决方法是使用 工厂设计模式 进行解耦合操作。所以，我们需要创建一个工厂类，在工厂类中提供一个方法，返回实现类的对象。

public class BeanFactory {
    // 提供返回实现类对象的方法
    public static UserDao getUserDao() {
        return new UserDaoImpl();
    }
}

这样，在service层中调用dao层的核心代码就变为了下面的样子。

UserDao dao = BeanFactory.getUserDao();
dao.add();

如若这样做，会发现又产生了一个缺点：现在接口和实现类之间是没有耦合了，但是service层和工厂类耦合了。如果真正想实现程序之间的解耦合，那么就需要使用到工厂设计模式+反射+XML配置文件了。所以，我们这里提供一个XML配置文件，并且该配置文件中有如下配置信息。

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

然后再来创建一个工厂类，在工厂类中提供一个返回实现类对象的方法，但并不是直接new实现类，而是使用SAX解析配置文件，根据标签bean中的id属性值得到对应的class属性值，使用反射创建实现类对象。

public class BeanFactory 
{
    public static Object getBean(String id) 
    {
        // 1.使用SAX解析得到配置文件内容
        // 直接根据id值userDao得到class属性值
        String classvalue = "class属性值";
        // 2.使用反射得到对象
        Class clazz = Class.forName(classvalue);
        UserDaoImpl userDaoImpl = (UserDaoImpl)clazz.newInstance();
        return userDaoImpl;
    }
}

DI

DI，即Dependency Injection，翻译过来就是依赖注入，它指的就是Spring在管理某个类的时候会将该类依赖的属性注入（设置）进来，也就是说在创建对象的过程中，向类里面的属性中设置值。

在面向对象设计的时候，类和类之间有3种关系:

依赖，由于下图中B类的方法用到了A类，所以此时就可以说B类依赖于A类；
继承（is a）

在这里插入图片描述

聚合（has a），它有松散和紧密之分。例如，球队得有一个守门员，即使这个球队没有了这个守门员，它也还是一个球队，所以它是松散的；人得有一个脑袋，此时它就是紧密的。

xml注入依赖：

在applicationContext.xml文件中为配置好的UserDaoImpl实现类的name属性注入一个值

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd">
        
	<!-- Spring入门的配置 -->
	<bean id="userDao" class="com.meimeixia.spring.demo01.UserDaoImpl">
		<!-- DI：依赖注入 -->
		<property name="name" value="李二" />
	</bean>
	
</beans>

对应的测试类：

package com.meimeixia.spring.demo01;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.FileSystemXmlApplicationContext;
public class SpringDemo01 {
	
	/*
	 * 传统方式的调用
	 */
	@Test
	public void demo01() {		
		/*
		 * 我想给这个类里面的某一个属性设置值，挺麻烦的！
		 * 
		 * 1. 不能面向接口编程了
		 * 2. 你还得手动调用set方法，也得去改变程序的源代码
		 */
		UserDaoImpl userDao = new UserDaoImpl();
		userDao.setName("李二");
		userDao.save();
	}
	
	/*
	 * Spring的方式的调用
	 */
	@Test
	public void demo02() {
		//先要创建Spring的工厂
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

}

Spring的工厂类

Spring工厂类的结构图

在这里插入图片描述

从上图可以看出ApplicationContext（接口）继承自BeanFactory（接口）。

BeanFactory：老版本的工厂类

BeanFactory是老版本的工厂类，稍微了解一下就好，这个类在实际开发中我们并不需要用到。需要说明的一点是，它只有在调用getBean方法的时候，才会生成Spring所管理的类的实例。

ApplicationContext：新版本的工厂类

ApplicationContext是新版本的工厂类，它在加载配置文件的时候，就会将Spring所管理的类都实例化。

注解驱动

以前学习Spring的过程中，我们是通过编写XML配置文件来定义我们的bean的，这种编写XML配置文件的方式不仅繁琐，而且还很容易出错，稍有不慎就会导致编写的应用程序各种报错，排查半天，发现是XML文件配置不对！此外，往往很多个项目的Spring XML文件的配置大部分是相同的，只有很少量的配置不同，这也造成了配置文件上的冗余。

通过注解注入JavaBean

通过XML配置文件的方式，我们可以将JavaBean注入到Spring的IOC容器中。那使用注解又该如何实现呢？别急，其实使用注解比使用XML配置文件要简单的多，我们在项目的com.meimeixia.config包下创建一个MainConfig类，并在该类上添加@Configuration注解来标注该类是一个Spring的配置类，也就是告诉Spring它是一个配置类，最后通过@Bean注解将Person类注入到Spring的IOC容器中。

原代码：

package com.meimeixia.bean;

public class Person {
	
	private String name;
	private Integer age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
}

主类：

package com.meimeixia;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.meimeixia.bean.Person;

public class MainTest {

	public static void main(String[] args) {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
		Person person = (Person) applicationContext.getBean("person");
		System.out.println(person);
	}
	
}

配置类：

package com.meimeixia.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import com.meimeixia.bean.Person;
/**
 * 以前配置文件的方式被替换成了配置类，即配置类==配置文件
 * @author liayun
 *
 */
// 这个配置类也是一个组件 
@Configuration                // 告诉Spring这是一个配置类
public class MainConfig 
{

	// @Bean注解是给IOC容器中注册一个bean，类型自然就是返回值的类型，id默认是用方法名作为id
	@Bean
	public Person person() {
		return new Person("liayun", 20);
	}
	
}

通过MainConfig类我们就能够将Person类注入到Spring的IOC容器中

然后，我们修改MainTest类中的main方法，以测试通过注解注入的Person类

package com.meimeixia;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.meimeixia.bean.Person;
import com.meimeixia.config.MainConfig;

public class MainTest {

	public static void main(String[] args) {
//		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
//		Person person = (Person) applicationContext.getBean("person");
//		System.out.println(person);
		
		ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MainConfig.class);
		Person person = applicationContext.getBean(Person.class);
		System.out.println(person);
	}
	
}