Spring学习 Spring IOC

迷南。 2024-02-05 22:16 66阅读 0赞

创建工程：

![cffa0c1c58c949d3bd219edbe782f4aa.png][]

### 2.1.程序的耦合 ###

*  耦合：耦合指的就是对象之间的依赖关系。对象之间的耦合越高，维护成本越高。
 *  案例：没有引入IOC容器时系统的Web层、业务层、持久层存在耦合
    
        /**
         * 持久层实现类
         */
        public class UserDaoImpl implements UserDao {
              
        
            @Override
            public void addUser(){
              
                System.out.println("insert into tb_user......");
            }
        }
    
        /**
         * 业务层实现类
         */
        public class UserServiceImpl implements UserService {
              
            //硬编码：此处有依赖关系
            private UserDao userDao = new UserDaoImpl();
        
            public void addUser(){
              
                userDao.addUser();
            }
        }
    
        /**
         * 模拟表现层
         */
        public class Client {
              
            public static void main(String[] args) {
              
                //硬编码：此处有依赖关系
                UserService userService = new UserServiceImpl();
                userService.addUser();
            }
        }
 *  问题分析：
    
    上边的代码service层在依赖dao层的实现类，此时如果更改dao了层的实现类或此时没有dao层实现类，编译将不能通过。
 *  IOC(工厂模式)解耦：
    
    1.  把所有的dao和service对象使用配置文件配置起来
    2.  当服务器启动时读取配置文件
    3.  把这些对象**通过反射创建**出来并**保存在容器中**
    4.  在使用的时候，直接从工厂拿

### 2.2.工程模式的IOC解决程序耦合 ###

#### 2.2.2.什么是IOC ####

*  IOC (Inverse of Control)即控制反转：正传是自己创建依赖对象；反正是有IOC工厂来创建依赖对象；
 *  原来：
    
    我们在获取对象时，都是采用new的方式。是主动的。
    
    ![1721f2756c094681b3a91bc8dcc2f6cf.jpeg][]
 *  现在：

我们获取对象时，同时跟工厂要，有工厂为我们查找或者创建对象。是被动的。

![aad26b74cb774fae937c36e412eb6bd0.jpeg][]

这种被动接收的方式获取对象的思想就是控制反转，它是spring框架的核心之一。

#### 2.2.3.工厂模式的IOC解耦 ####

*  案例一
    
        /**
         * bean工厂
         */
        public class BeanFactory_v1 {
              
        
            /**
             * 获得UserServiceImpl对象
             * @return
             */
            public static UserService getUserService(){
              
                return new UserServiceImpl();
            }
        
            /**
             * 获得UserDaoImpl对象
             * @return
             */
            public static UserDao getUserDao(){
              
                return new UserDaoImpl();
            }
        }
    
    问题：我们在开发中会有很多个service和dao，此时工厂类就要添加无数个方法。
 *  案例二
    
        #1、配置要使用的dao和service
        UserDao=com.by.dao.UserDaoImpl
        UserService=com.by.service.UserServiceImpl
    
        /**
         * bean工厂
         */
        public class BeanFactory_v2 {
              
        
            private static Properties prop = new Properties();
        
            /**
             * 根据全类名获取bean对象
             * @param beanName
             * @return
             * @throws ClassNotFoundException
             */
            public static Object getBean(String beanName) {
              
                try {
              
                    //不能使用：web工程发布后没有src目录
                    //InputStream is = new FileInputStream("src/bean.properties");
                    InputStream is = 
                    BeanFactory_v2.class.getClassLoader()
                        .getResourceAsStream("bean.properties");
                    prop.load(is);
                    return Class.forName(prop.getProperty(beanName)).newInstance();
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
                return null;
            }
        
            public static void main(String[] args) {
              
                System.out.println(prop.get("UserService"));
                System.out.println(getBean("UserService"));
            }
        }
    
        /**
         * 业务层实现类
         */
        public class UserServiceImpl implements UserService {
              
            
            private UserDao userDao = (UserDao) BeanFactory.getBean("UserDao");
        
            public void addUser(){
              
              userDao.addUser();
            }
        }
    
    测试：
    
        /**
         * 模拟表现层
         */
        public class Client {
              
            public static void main(String[] args) {
              
                //直接引用接口实现类
              for (int i = 0; i < 5; i++) {
              
                    UserService userService = 
                      (UserService)BeanFactory.getBean("UserService");
                    System.out.println(userService);
                }
            }
        }
    
    ![7e70e90ec9644569aa27a028e21e049b.png][]
    
    问题：
    
    1.  每次都会创建新的对象
    2.  程序运行时才创建对象(读取配置文件)
 *  案例三
    
        package com.by.factory;
        
        import java.io.InputStream;
        import java.util.HashMap;
        import java.util.Map;
        import java.util.Properties;
        import java.util.Set;
        
        /**
         * bean工厂
         */
        public class BeanFactory_v3 {
              
        
            //定义一个容器，用于存放对象
            private static Map<String, Object> beans = new HashMap<>();
        
            /**
             * 加载配置文件
             */
            static {
              
                try {
              
                    //2、读取配置文件
                    //不能使用：web工程发布后没有src目录
                    //InputStream is = new FileInputStream("src/bean.properties");
                    InputStream is = 
                    BeanFactory_v3.class.getClassLoader()
                        .getResourceAsStream("bean.properties");
        
                    //3、通过反射创建对象,把对象存到容器中
                    Properties prop = new Properties();
                    prop.load(is);
                    Set<Map.Entry<Object, Object>> entrySet = prop.entrySet();
                    for (Map.Entry<Object, Object> entry : entrySet) {
              
                        String key = entry.getKey().toString();
                        String beanName = entry.getValue().toString();
                        Object value = Class.forName(beanName).newInstance();
                        beans.put(key, value);
                    }
        
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
            }
        
            /**
             * 4、在使用的时候，直接从工厂拿
             * @param beanName
             * @return
             */
            public static Object getBean(String beanName) {
              
                try {
              
                    return beans.get(beanName);
                } catch (Exception e) {
              
                    e.printStackTrace();
                }
                return null;
            }
        
            public static void main(String[] args) {
              
                System.out.println(getBean("UserService"));
            }
        }

### 2.3.Spring的IOC解决程序耦合 ###

#### 2.3.1.创建工程 ####

![77eb382dd02f4fe8946cdf5399687102.png][]

##### 2.3.1.1.pom.xml #####

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.by</groupId>
        <artifactId>Spring_IOC_Xml</artifactId>
        <version>1.0-SNAPSHOT</version>
        
        <properties>
            
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            
            <maven.compiler.source>8</maven.compiler.source>
            <maven.compiler.target>8</maven.compiler.target>
        </properties>
        
        <dependencies>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>5.1.8.RELEASE</version>
            </dependency>
        </dependencies>
    </project>

注意：Jar包彼此存在依赖，只需引入最外层Jar即可由Maven自动将相关依赖Jar引入到项目中。

<table> 
 <thead> 
  <tr> 
   <th align="center">Spring常用功能的Jar包依赖关系</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center"><img src="https://img-blog.csdnimg.cn/direct/bf2f0ebeab0547ecbea0683feefa1f49.png" alt="请添加图片描述"></td> 
  </tr> 
 </tbody> 
</table>

核心容器由 beans、core、context 和 expression（Spring Expression Language，SpEL）4个模块组成。

*  spring-beans和spring-core模块是Spring框架的核心模块，包含了控制反转（Inversion of Control，IOC）和依赖注入（Dependency Injection，DI）。BeanFactory使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。BeanFactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化Bean，只有当Bean被使用时，BeanFactory才会对该 Bean 进行实例化与依赖关系的装配。
 *  spring-context模块构架于核心模块之上，扩展了BeanFactory，为它添加了Bean生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，ApplicationContext 是该模块的核心接口，它的超类是 BeanFactory。与BeanFactory不同，ApplicationContext实例化后会自动对所有的单实例Bean进行实例化与依赖关系的装配，使之处于待用状态。
 *  spring-expression 模块是统一表达式语言（EL）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统EL，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。EL的特性是基于Spring产品的需求而设计的，可以非常方便地同Spring IoC进行交互。

##### 2.3.1.2.dao #####

/**
     * 持久层实现类
     */
    public class UserDaoImpl implements UserDao {
        
    
        @Override
        public void addUser(){
        
            System.out.println("insert into tb_user......");
        }
    }

##### 2.3.1.3.service #####

/**
     * 业务层实现类
     */
    public class UserServiceImpl implements UserService {
        
        //此处有依赖关系
        private UserDao userDao = new UserDaoImpl();
    
        public void addUser(){
        
            userDao.addUser();
        }
    }

#### 2.3.2.IOC ####

##### 2.3.2.1.applicationContext.xml #####

注意：命名无限制，约定俗成命名有：spring-context.xml、applicationContext.xml、beans.xml

##### 2.3.2.2.测试 #####

/**
     * 模拟表现层
     */
    public class Client {
        
        public static void main(String[] args) {
        
            //1.使用ApplicationContext接口，就是在获取spring容器
            ApplicationContext ac = new 
                ClassPathXmlApplicationContext("applicationContext.xml");
            //2.根据bean的id获取对象
            UserDao userDao = (UserDao) ac.getBean("userDao");
            System.out.println(userDao);
    
            UserService userService = (UserService) ac.getBean("userService");
            System.out.println(userService);
            userService.addUser();
        }
    }

*  问题：service层仍然耦合

#### 2.3.3.DI ####

概述：DI（Dependency Injection）依赖注入：将依赖对象从容器中拿出来赋值给调用者

##### 2.3.3.1.构造函数注入 #####

顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让spring框架来为我们注入。具体代码如下：

/**
     * 业务层实现类
     */
    public class UserServiceImpl implements UserService {
        
    
        private UserDao userDao;
        private String name;
        private Integer age;
    
        public UserServiceImpl(UserDao userDao, String name, Integer age) {
        
            this.userDao = userDao;
            this.name = name;
            this.age = age;
        }
    
        public void addUser(){
        
            System.out.println(name+","+age);
            userDao.addUser();
        }
    }

##### 2.3.3.2.set方法注入 #####

顾名思义，就是在类中提供需要注入成员的set方法。具体代码如下：

/**
     * 业务层实现类
     */
    public class UserServiceImpl implements UserService {
        
    
        private UserDao userDao;
        private String name;
        private Integer age;
    
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public void setAge(Integer age) {
        
            this.age = age;
        }
    
        public void addUser(){
        
            System.out.println(name+","+age);
            userDao.addUser();
        }
    }

##### 2.3.3.3.自动注入 #####

不用在配置中 指定为哪个属性赋值，由spring自动根据某个 “原则” ，在工厂中查找一个bean并为属性注入值。具体代码如下：

/**
     * 业务层实现类
     */
    public class UserServiceImpl implements UserService {
        
    
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }
    
        public void addUser(){
        
            userDao.addUser();
        }
    }

##### 2.3.3.4.注入集合类型的属性 #####

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，List,Set,Map。具体代码如下：

/**
     * 业务层实现类
     */
    public class UserServiceImpl implements UserService {
        
    
        private UserDao userDao;
        private String[] myStrs;
        private List<String> myList;
        private Set<String> mySet;
        private Map<String,String> myMap;
    
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }
    
        public void setMyStrs(String[] myStrs) {
        
            this.myStrs = myStrs;
        }
    
        public void setMyList(List<String> myList) {
        
            this.myList = myList;
        }
    
        public void setMySet(Set<String> mySet) {
        
            this.mySet = mySet;
        }
    
        public void setMyMap(Map<String, String> myMap) {
        
            this.myMap = myMap;
        }
    
        public void addUser(){
        
            System.out.println(Arrays.toString(myStrs));
            System.out.println(myList);
            System.out.println(mySet);
            System.out.println(myMap);
            userDao.addUser();
        }
    }

<?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="userDao" class="com.by.dao.UserDaoImpl"></bean>
        <bean id="userService" class="com.by.service.UserServiceImpl">
            
            <property name="userDao" ref="userDao"></property>
            
            <property name="mySet">
                <set>
                    <value>AAA</value>
                    <value>BBB</value>
                    <value>CCC</value>
                </set>
            </property>
            
            <property name="myArray">
                <array>
                    <value>AAA</value>
                    <value>BBB</value>
                    <value>CCC</value>
                </array>
            </property>
            
            <property name="myList">
                <list>
                    <value>AAA</value>
                    <value>BBB</value>
                    <value>CCC</value>
                </list>
            </property>
            
            <property name="myMap">
                <map>
                    <entry key="testA" value="aaa"></entry>
                    <entry key="testB" value="bbb"></entry>
                </map>
            </property>
        </bean>
    </beans>

### 2.4.Spring中的工厂类 ###

#### 2.4.1.ApplicationContext ####

*  ApplicationContext的实现类，如下图：
    
    ![c7ff56ef8a4b40518e2905b760f2c878.jpeg][]
    
     *  ClassPathXmlApplicationContext：加载类路径下 Spring 的配置文件
     *  FileSystemXmlApplicationContext：加载本地磁盘下 Spring 的配置文件

#### 2.4.2.BeanFactory ####

*  spring中工厂的类结构图
    
    ![90d1dd68c3ee4d94924534b3ca04f064.png][]
 *  区别：
    
     *  ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
        
            /**
             * 业务层实现类
             */
            public class UserServiceImpl implements UserService {
                    
            
                private UserDao userDao;
            
                public UserServiceImpl() {
                    
                    System.out.println("UserServiceImpl对象创建了...");
                }
            
                public void setUserDao(UserDao userDao) {
                    
                    this.userDao = userDao;
                }
            
                public void addUser(){
                    
                    userDao.addUser();
                }
            }
        
            /**
             * 模拟表现层
             */
            public class Client {
                    
                public static void main(String[] args) {
                    
                    new ClassPathXmlApplicationContext("applicationContext.xml");
                    System.out.println("Spring IOC容器创建好了");
                }
            }
 *  BeanFactory：是在 getBean 的时候才会创建对象。
    
        /**
         * 业务层实现类
         */
        public class UserServiceImpl implements UserService {
              
        
            private UserDao userDao;
        
            public UserServiceImpl() {
              
                System.out.println("UserServiceImpl对象创建了...");
            }
        
            public void setUserDao(UserDao userDao) {
              
                this.userDao = userDao;
            }
        
            public void addUser(){
              
                userDao.addUser();
            }
        }
    
        /**
        * 模拟表现层
        */
        public class Client {
              
          public static void main(String[] args) {
              
              new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
              System.out.println("Spring IOC容器创建好了");
          }
        }

### 2.5.bean的作用范围 ###

#### 2.5.1.概述 ####

*  在Spring中，bean作用域用于确定bean实例应该从哪种类型的Spring容器中返回给调用者。

#### 2.5.2.五种作用域 ####

*  目前Spring Bean的作用域或者说范围主要有五种：
    
    <table> 
     <thead> 
      <tr> 
       <th>作用域</th> 
       <th>说明</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td>singleton</td> 
       <td>默认值，Bean以单例方式存在spring IoC容器</td> 
      </tr> 
      <tr> 
       <td>prototype</td> 
       <td>每次从容器中调用Bean时都返回一个新的实例，相当于执行newInstance()</td> 
      </tr> 
      <tr> 
       <td>request</td> 
       <td>WEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 request 域中</td> 
      </tr> 
      <tr> 
       <td>session</td> 
       <td>WEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 session 域中</td> 
      </tr> 
      <tr> 
       <td>application</td> 
       <td>WEB 项目中，Spring 创建一个 Bean 的对象,将对象存入到 ServletContext 域中</td> 
      </tr> 
     </tbody> 
    </table>
 *  可以通过 `<bean>` 标签的`scope` 属性控制bean的作用范围，其配置方式如下所示：
    
        <bean id="..." class="..." scope="singleton"/>

*  需要根据场景决定对象的单例、多例模式
    
    单例：Service、DAO、SqlSessionFactory（或者是所有的工厂）
    
    多例：Connection、SqlSession

### 2.6.bean的生命周期 ###

#### 2.6.1.单例bean ####

*  案例
    
        <bean id="userService" class="com.by.service.UserServiceImpl"
              			scope="singleton" init-method="init" destroy-method="destroy">
    
        /**
         * 业务层实现类
         */
        public class UserServiceImpl implements UserService {
              
        
            private UserDao userDao;
        
            public UserServiceImpl() {
              
                System.out.println("调用构造方法创建bean...");
            }
        
            public void setUserDao(UserDao userDao) {
              
                System.out.println("调用set方法注入值...");
                this.userDao = userDao;
            }
        
            public void init(){
              
                System.out.println("调用init方法初始化bean...");
            }
        
            public void destroy(){
              
                System.out.println("调用destroy方法销毁bean...");
            }
        
            public void addUser(){
              
                userDao.addUser();
            }
        }
    
        /**
         * 模拟表现层
         */
        public class Client {
              
            public static void main(String[] args) {
              
                ClassPathXmlApplicationContext ac = 
                	new ClassPathXmlApplicationContext("applicationContext.xml");
                //关闭容器
                ac.close();
            }
        }
 *  生命周期：
    
    > \[容器启动\]—>构造方法(实例化)—>set方法(注入)—>init方法(初始化)—>\[容器关闭\]—>destroy方法(销毁)
    
    ![d495e5c0f2804a4c9dce1340fe98e0d9.png][]

#### 2.5.2.多例bean ####

*  案例
    
        <bean id="userService" class="com.by.service.UserServiceImpl"
              			scope="prototype" init-method="init" destroy-method="destroy">
    
        /**
         * 业务层实现类
         */
        public class UserServiceImpl implements UserService {
              
        
            private UserDao userDao;
        
            public UserServiceImpl() {
              
                System.out.println("调用构造方法创建bean...");
            }
        
            public void setUserDao(UserDao userDao) {
              
                System.out.println("调用set方法注入值...");
                this.userDao = userDao;
            }
        
            public void init(){
              
                System.out.println("调用init方法初始化bean...");
            }
        
            public void destroy(){
              
                System.out.println("调用destroy方法销毁bean...");
            }
        
            public void addUser(){
              
                userDao.addUser();
            }
        }
    
        /**
         * 模拟表现层
         */
        public class Client {
              
            public static void main(String[] args) {
              
                ClassPathXmlApplicationContext ac = 
                    	new ClassPathXmlApplicationContext("applicationContext.xml");
                //使用对象
                ac.getBean("userService");
            }
        }

生命周期：

> \[使用对象\]---->构造方法(实例化)—>set方法(注入)—>init方法(初始化)—>\[JVM垃圾回收\]—>destroy方法(销毁)

![在这里插入图片描述][fcd1c9da04224ec58d62760cb16f4481.png]

[cffa0c1c58c949d3bd219edbe782f4aa.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/10f1a63a798945dca6f3b08ef1f1dac8.png
[1721f2756c094681b3a91bc8dcc2f6cf.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/bd2b60366078430da0ecf22169c2f141.png
[aad26b74cb774fae937c36e412eb6bd0.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/26dddc5f073a40b7adacf4e8150c1414.png
[7e70e90ec9644569aa27a028e21e049b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/68d1d70686e84baebb00c2f2c4f76908.png
[77eb382dd02f4fe8946cdf5399687102.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/ca074733f7184c13afdb771109b7d0c9.png
[c7ff56ef8a4b40518e2905b760f2c878.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/e5546233016f46f2834d24b2f0ee315f.png
[90d1dd68c3ee4d94924534b3ca04f064.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/b9c3ddc95d064652b2f9ba8caea3d8eb.png
[d495e5c0f2804a4c9dce1340fe98e0d9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/b12896ec5ca24a08b97b2ffac8a08c33.png
[fcd1c9da04224ec58d62760cb16f4481.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/5078241eb81f418a868ac7b9ec777e08.png