Spring学习记录（二）：Spring IOC学习

最新推荐文章于 2024-09-17 14:09:31 发布
最新推荐文章于 2024-09-17 14:09:31 发布
阅读量544 收藏
点赞数
分类专栏： Spring学习 文章标签： spring java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44544536/article/details/120129700
版权

Spring学习记录（二）：Spring IOC学习

提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

前言

       上一篇概括了Spring的概念问题、优势以及框架结构，现在正式进入IOC的整理。

一、IOC是什么？

       控制反装不是一种技术，而是设计思想。他的目的很明确，为设计出更加松耦合的程序。其中控制指的是程序中对象的控制权限，反转指的是对象的控制权由原来的开发者转移到Spring容器控制。

二、IOC容器的自定义

1.引入库

<dependencies>
        <dependency>
            <groupId>dom4j</groupId>
            <artifactId>dom4j</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>jaxen</groupId>
            <artifactId>jaxen</artifactId>
            <version>1.1.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

2.传统方法编写

       编写Dao层代码：

public interface UserDao {
    void save();
}

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("保存成功");
    }
}

       编写service层：

public interface UserService {
    void save();
}

public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        UserDao userDao = new UserDaoImpl();
        userDao.save();
    }
}

       编写测试代码：

public class SpringTest {
    @Test
    public void test1(){
        UserService userService=new UserServiceImpl();
        userService.save();
    }
}

       我们可以看到，传统方式调用存在编译期依赖，耦合过高，而且每次new对象会造成服务器压力过大，我们最重要的就是去掉这个new对象的过程完成解耦合。

3.改造传统方法，降低耦合度（自定义IOC容器）

       使用反射去掉new关键字：

public class UserServiceImpl implements UserService {
    @Override
    public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        //UserDao userDao = new UserDaoImpl();
        //使用反射
        UserDao userDao = (UserDao) Class.forName("com.ssm.dao.impl.UserDaoImpl").newInstance();
        userDao.save();
    }
}

在编译期就算没有Dao也不会报错，解决编译期依赖问题。但是存在硬编码问题。改造思路：反射+配置文件。
       改造步骤分析：
              1.准备一个配置文件：beans.xml

<beans>
    <!--id:标识   class:存的全路径-->
    <bean id="UserDao" class="com.ssm.dao.impl.UserDaoImpl"></bean>
</beans>

              2.编写一个工厂工具类，工厂类使用dom4j来解析配置文件，获取到类全路径。
              3.使用反射生成对应类的实例对象，存到map中（IOC容器）。

public class BeanFactory {

    private static Map<String, Object> iocMap = new HashMap<>();

    //程序启动时，初始化对象实例
    static {
        //1.读取配置文件
        InputStream resourceAsStream = BeanFactory.class.getClassLoader().getResourceAsStream("beans.xml");
        //2.解析xml（使用dom4j）
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(resourceAsStream);
            //3.编写xpath表达式
            String xpath = "//bean";
            //4.获取到所有bean标签
            List<Element> list = document.selectNodes(xpath);
            //5.遍历并使用反射创建对象实例，存到map中（充当IOC容器）
            for (Element element : list) {
                String id = element.attributeValue("id");
                String className = element.attributeValue("class");
                //6.使用反射生成实例对象
                Object o = Class.forName(className).newInstance();
                //7.存入map中 key:id value:o
                iocMap.put(id, o);
            }
        } catch (DocumentException | ClassNotFoundException | InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
        }
    }
    public static Object getBean(String beanId){
        return iocMap.get(beanId);
    }
}

              4.调用。

public class UserServiceImpl implements UserService {
    @Override
    public void save() throws ClassNotFoundException, InstantiationException, IllegalAccessException {

        //UserDao userDao = new UserDaoImpl();
        //使用反射
        //UserDao userDao = (UserDao) Class.forName("com.ssm.dao.impl.UserDaoImpl").newInstance();
        //利用工厂类进行获取
        UserDao userDao = (UserDao)BeanFactory.getBean("userDao");
        userDao.save();
    }
}

4.总结

      BeanFactory就是一个简单的IOC容器，之前我们需要一个UserDao实例来new对象，现在我们只需要交给Bean工厂（IOC）控制，达到解耦合的目的。

三、利用Spring进行快速入门

1.引入库

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>

2.编写核心配置文件

      依旧利用上文的Dao形式，创建配置文件applicationContext.xml（不要忘记约束头）

<bean id="UserDao" class="com.ssm.dao.impl.UserDaoImpl"></bean>

3.利用SpringAPI获取

public class SpringTest {
    @Test
    public void test1(){
        //获取spring上下文对象，借助上下文对象可以获取到IOC容器中的bean对象
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        //使用上下文对象，从IOC容器中获取Bean对象
        UserDao userDao = (UserDao) applicationContext.getBean("UserDao");
        userDao.sava();
    }
}

四、Spring相关API

      主要关注BeanFactory和ApplicationContext
在这里插入图片描述

1.BeanFactory

      BeanFactory是IOC容器的核心接口，定义了IOC基本功能。

public void test2(){
        //核心接口，但是不会创建bean对象存入容器中
        BeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
        //在getBean的时候才真正创建bean对象
        UserDao userDao = (UserDao)xmlBeanFactory.getBean("UserDao");
        userDao.sava();
    }

2.ApplicationContext

     代表应用上下文对象，获得IOC容器的Bean对象。
     特点：启动时就创建并加载所有实例（和BeanFactory的不同之处）。
     常用实现类：

//当使用注解配置容器对象时，创建Spring容器读取注释
 AnnotationConfigApplicationContext
//从磁盘路径加载配置文件
FileSystemXmlApplicationContext
//从类的根路径加载配置文件
ClassPathXmlApplicationContext

     常用的getBean有三个：

//根据Bean的id从容器中获得Bean实例，需要强转
Object getBean(String var1) throws BeansException;
//根据类型从容器中获取Bean实例，当有多个相同类型时，会报错
<T> T getBean(Class<T> var1) throws BeansException;
//根据Bean的id和类型获取Bean实例，结合上面两种方法
<T> T getBean(String var1, Class<T> var2) throws BeansException;

PS：getBean方法来自BeanFactory接口。

五、Spring配置文件

1.基本配置

<bean id="" class="" scope=""></bean>
#默认调用类中的无参构造
取值范围说明
singleton默认值，单例的
prototype多例的
requestWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
sessionWEB 项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global sessionWEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

2.Bean的生命周期

<bean id="" class="" scope="" init-method="" destroy-method=""></bean>

init-method=""      初始化。
destroy-method=""     销毁时。

六、Bean实例化三种方式

无参构造实例化
工厂静态方法实例化
工厂普通方法实例化

1.工厂静态方法实例化

   假设依赖jar包中有个A类，A类中有静态方法a1，其返回值是一个B对象，如果我们频繁调用B对象，那我们可以将创建权交给SpringIOC进行处理。

public class StaticFactoryBean {
    static UserDao createUserDao(){
        return new UserDaoImpl();
    }
}

<bean id="userDao" class="com.ssm.dao.StaticFactoryBean" factory-method="createUserDao"></bean>

2.工厂普通方法实例化

   假设依赖jar包中有个A类，A类中有普通方法a1，其返回值是一个B对象，如果我们频繁调用B对象，那我们可以将创建权交给SpringIOC进行处理。

public class DynamicFactoryBean {
    public UserDao createUserDao() {
        return new UserDaoImpl();
    }
}

<bean id="dynamicFactoryBean" class="com.ssm.dao.DynamicFactoryBean"></bean>
<bean id="userDao" factory-bean="dynamicFactoryBean" factory-method="createUserDao"></bean>

七、Bean依赖注入

1.依赖注入概述

   他是SpringIOC的具体实现，通过控制反转后，通过框架把持久层对象传入业务层，而不用我们自己去获取。

2.Bean依赖注入的方式

2.1 构造方法

   在UserServiceImpl中创建有参构造

public class UserServiceImpl implements UserService {

    private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }
    
    @Override
    public void save() {
        userDao.sava();
    }
}

   配置xml

<bean id="UserDao" class="com.ssm.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.ssm.service.impl.UserServiceImpl">
	<constructor-arg index="0" type="com.ssm.dao.UserDao" ref="UserDao"></constructor-arg>
</bean>

   测试

 @Test
    public void test3(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService)applicationContext.getBean("userService");
        userService.save();
    }

2.1 set方法（比较常用）

   在UserServiceImpl中创建有参构造（把有参构造删除）

public class UserServiceImpl implements UserService {

    private UserDao userDao;

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

    @Override
    public void save() {
        userDao.sava();
    }
}

   配置xml

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

   测试

 @Test
    public void test3(){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = (UserService)applicationContext.getBean("userService");
        userService.save();
    }

3.Bean依赖注入的数据类型

3.1 普通数据类型

   改造一下UserDaoImpl

 public class UserDaoImpl implements UserDao {

    private String username;
    private String password;

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public void sava() {
    	System.out.println(username);
        System.out.println(password);
        System.out.println("保存成功");
    }
}

   配置xml

<bean id="UserDao" class="com.ssm.dao.impl.UserDaoImpl">
        <property name="username" value="admin"></property>
        <property name="password" value="123456"></property>
    </bean>
    <bean id="userService" class="com.ssm.service.impl.UserServiceImpl">
        <property name="userDao" ref="UserDao"></property>
    </bean>

测试一下~

3.2 集合数据类型

   利用上述普通类型注入创建一个User对象并注入容器（练习一下）
   改造一下UserDaoImpl

public class UserDaoImpl implements UserDao {

    private List<Object> list;
    private Set<Object> set;
    private Object[] array;
    private Map<String,Object> map;
    private Properties properties;

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

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

    public void setArray(Object[] array) {
        this.array = array;
    }

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

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

    @Override
    public void sava() {
        System.out.println(list);
        System.out.println(set);
        System.out.println(Arrays.toString(array));
        System.out.println(map);
        System.out.println(properties);
        System.out.println("保存成功");
    }


}

   配置xml

<bean id="User" class="com.ssm.damain.User">
        <property name="username" value="admin"></property>
        <property name="password" value="123456"></property>
    </bean>

    <bean id="UserDao" class="com.ssm.dao.impl.UserDaoImpl">
        <property name="list">
            <list>
                <value>simon</value>
                <ref bean="User"></ref>
            </list>
        </property>
        <property name="set">
            <set>
                <value>simon2</value>
                <ref bean="User"></ref>
            </set>
        </property>
        <property name="array">
            <array>
                <value>simon3</value>
                <ref bean="User"></ref>
            </array>
        </property>
        <property name="map">
            <map>
                <entry key="1" value="simon4"></entry>
                <entry key="2" value-ref="User"></entry>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="k1">v1</prop>
                <prop key="k2">v2</prop>
            </props>
        </property>
    </bean>
    <bean id="userService" class="com.ssm.service.impl.UserServiceImpl">
        <property name="userDao" ref="UserDao"></property>
    </bean>

测试一下~

八、Spring注解开发

1.常用注解介绍（IOC）

注解说明
@Component使用在类上用于实例化Bean
@Controller对应表现层的Bean
@ Service对应的是业务层Bean
@ Repository对应数据访问层Bean
@Autowired使用在字段上根据类型进行依赖注入

   只要根据对应业务层中加入相关注解即可代替xml中的相关bean标签，如Service层改写：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

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

    @Override
    public void save() {
        userDao.sava();
    }
}
SimonTH4
关注
专栏目录
“掌握Spring IoC和AOP：30道面试必备问题解析！“
weixin_44976692的博客
01-03 2万+
在面试过程中，Spring的IoC（控制反转）和AOP（面向切面编程）是被频繁问及的重要主题。掌握这两个核心概念和技术，对于成为一名优秀的Java开发者至关重要。本篇博客将为你提供一份包含20个关键问题的面试指南，助你在面试中游刃有余，展现出对Spring IoC和AOP的深刻理解。无论你是初学者还是有经验的开发者，这20个问题将覆盖IoC和AOP的核心知识点，帮你更好地准备面试。让我们一同深入探讨，揭秘Spring的IoC和AOP的奥秘，为你的面试之路加分不少！🚀💻。
深入理解Spring两大特性：IoC和AOP
热门推荐
null
02-14 9万+
众所周知，Spring拥有两大特性：IoC和AOP。。Spring核心容器的主要组件是Bean工厂（BeanFactory），Bean工厂使用控制反转（IoC）模式来降低程序代码之间的耦合度，并提供了面向切面编程（AOP）的实现。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。下面，我们简要说明下这两大特性。
系统学习SpringFramework：Spring IOC
栗筝i的博客
11-01 5143
本篇内容包括：IOC 和 DI 的概念、Spring 容器，即 BenaFactory 与 AplicationConext 等 IOC 相关内容。
Spring学习：IOC控制反转
sssxlxwbwz的博客
02-01 1741
一、Spring概述： Spring是一个开源框架，其存在的根本使命就是简化JAVA开发。为了降低JAVA开发的复杂性，Spring采取了以下四种关键策略： 基于POJO的最轻量级和最小侵入性编程； 通过依赖注入和面向接口实现松耦合； 基于切面和惯例进行声明式编程； 通过切面和模板减少样板式代码。 1.1 Spring有两个核心部分：IOC和AOP: (1) IOC: 控制反转，把创建对象过程交给Spring进行管理； (2) AOP: 面向切面，不修改源代码，...
Spring学习笔记（一）——IOC
啦啦啦的博客
03-11 1119
一、Spring概述 1、spring是开源的轻量级框架 2、spring核心的两个部分 aop：面向切面编程，扩展功能可以不修改源码。 ioc：控制反转，对象的创建不再通过new，而是交给spring配置创建类对象。 3、spring是一个一站式框架 web层：SpringMVC service层：Spring的ioc dao层：Spring的jdbcTemplate 二...
Spring的IOC学习之三
aurora125的博客
03-18 143
1. IOC基于xml的配置方式 同样以战士的例子进行学习，在上面那篇博客提到的有Knight，Weapon，Axe，Knife，Gun等文件。 1.1 首先创建beans.xml,并且引入spring的schema <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.or...
SpringIOC：SpringIOC临时二进制简单实现
02-15
在这个"SpringIOC：SpringIOC临时二进制简单实现"中，我们将探讨如何在Java环境下构建一个简单的Spring IOC的二进制实现。 首先，理解控制反转的基本概念。在传统的编程模式中，对象通常自行创建依赖的对象，这导致...
Spring 学习笔记①：IoC容器、Bean与注入
身披白袍的博客
07-05 2651
IoC容器、Bean与注入
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
深入解析Spring IoC：源码与实践指南
12-13
在深入解析Spring IoC的过程中，我们首先关注的是其核心组件——IoC（Inversion of Control，控制反转）机制。Spring框架通过IoC容器管理应用程序的组件，实现了依赖注入，使得对象之间的依赖关系由容器负责建立和...
Spring Framework 学习总结博客
2302_80084329的博客
09-13 1035
通过本文的学习，我们从Spring的核心架构入手，逐步理解了IoC和DI的概念，并通过代码示例掌握了如何在实际项目中使用这些技术。Spring通过IoC容器管理bean，依赖注入将bean之间的关系解耦，大大简化了复杂系统的开发过程。这些基本的Spring知识是理解其高级特性（如AOP、事务管理）的基础，掌握这些概念后，我们可以更加自如地使用Spring构建复杂的企业级应用。
基于spring的博客系统（总）
2202_76101487的博客
09-12 1394
本文写了基于spring mvc创建的博客系统；
java项目之基于springboot的贸易行业crm系统（源码+文档）
sinat_26552841的博客
09-13 453
基于springboot的贸易行业crm系统的主要使用者分为： 管理员功能有个人中心，部门管理，员工管理，产品分类管理，产品信息管理，客户信息管理，市场活动管理，销售订单管理，配送订单管理。员工可以操作自己的个人中心，客户信息，产品信息，销售订单，配送订单，售后回访等。
spring综合性利用工具-SpringBootVul-GUI(五)
siu~
09-12 855
一个半自动化springboot打点工具，内置目前springboot所有漏洞
springboot3.X版本集成mybatis遇到的问题
SmileAssassn的博客
09-15 417
最根本的原因是搜出来的配置是参照springboot2.X版本，当我们使用springboot3.x版本之后，需要配置使用3.0.3及以上的mybatis才行，否则的话就会出现无法注入mapper的bean的问题。参照我如下的maven配置即可完美解决该问题，使用3.0.3版本的mybatis就可以完美适配springboot3.X版本。当我参照如下搜索的内容去集成mybatis的时候，会出现各种各样的报错。由于我本地springboot为3.x版本，如下图所示，最新版本。
RabbitMQ Spring客户端使用
lixiaotao_1的博客
09-17 200
java自带序列化工具类，将java对象序列化为字节数组，用于网络传输。jdk序列号存在缺陷，（不安全，占用空间大等）注解声明式队列和交换机。
基于springboot学生健康管理系统的设计与实现
最新发布
2401_87134477的博客
09-17 1117
国内对健康信息管理的意识一直较为落后，直到近年来随着经济水平的提高和信息技术的发展，国内对健康管理的研究和相关系统的开发渐渐多了起来。基于选题的具体要求，我已经广泛查阅相关文献资料，对比近年来的各种信息管理系统以及其运用的相关技术，发现近年来流行的Springboot技术也已经越来越多的应用到各类系统。本选题采用Springboot技术主要是因为它不需要进行大量的配置工作，并且它将流行的组件框架的依赖库进行了分组整合，在开发的过程中可以一次性添加到项目的Maven中。实现学生健康资料的规范化管理。
k8s部署springcloud-alibaba项目
Devil的博客
09-12 811
k8s部署spring cloud alibaba项目，技术涉及k8s，flannel，nfs，mysql，nginx、nacos、sentinel、seata，需要有一定的知识储备，不面向0基础
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 944
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
Spring框架学习笔记：IoC与AOP解析
"Spring_in_action_学习笔记" Spring框架是Java开发中的一个重要组成部分，以其轻量级、非侵入式的设计理念赢得了广泛的认可。本学习笔记主要涵盖了Spring的基础知识，包括核心特性和模块组成。 1. Spring核心特性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值