【IOC&Spring配置】

淡淡的烟草味﹌ 2024-03-22 11:15 20阅读 0赞

### IOC理论推导 ###

*  先写一个UserDao接口

public interface UserDao {
        
        void getUser();
    }

*  再写一个Dao的实现类

public class UserDaoImpl implements UserDao{
        
    
        @Override
        public void getUser() {
        
            System.out.println("默认获取用户的数据");
        }
    }

*  写UserService的接口

public interface UserService {
        
        void getUser();
    }

*  写Service的实现类

package com.canso.service;
    
    import com.canso.dao.UserDao;
    import com.canso.dao.UserDaoImpl;
    import com.canso.dao.UserDaoMysqlImpi;
    import com.canso.dao.UserDaoOracleImpl;
    
    public class UserServiceImpl implements UserService{
        
        private UserDao userDao = new UserDaoImpl();
    
        @Override
        public void getUser() {
        
            userDao.getUser();
        }
    }

*  测试

现在添加一个UserDao的实现类

public class UserDaoMysqlImpi implements UserDao{
        
        @Override
        public void getUser() {
        
            System.out.println("MySQL获取用户数据");
        }
    }

若要使用Mysql,需要去Service实现类里面修改对应的实现new对象

package com.canso.service;
    
    import com.canso.dao.UserDao;
    import com.canso.dao.UserDaoImpl;
    import com.canso.dao.UserDaoMysqlImpi;
    import com.canso.dao.UserDaoOracleImpl;
    
    public class UserServiceImpl implements UserService{
        
       private UserDao userDao = new UserDaoMysqlImpi ();
    
       @Override
       public void getUser() {
        
           userDao.getUser();
       }
    }

若我们还有其他类需要调用，还需要手动修改Service实现类，显然，这种设计的耦合性太高了

那么我们可以这样处理  
我们可以在需要用到它的地方不去实现它，而是留出一个接口，利用set进行传参

package com.canso.service;
    
    import com.canso.dao.UserDao;
    import com.canso.dao.UserDaoImpl;
    import com.canso.dao.UserDaoMysqlImpi;
    import com.canso.dao.UserDaoOracleImpl;
    
    public class UserServiceImpl implements UserService{
        
        private UserDao userDao;
        public void setUserDao(UserDao userDao) {
        
            this.userDao = userDao;
        }
    
        @Override
        public void getUser() {
        
            userDao.getUser();
        }
    }

测试类

import com.canso.dao.UserDaoImpl;
    import com.canso.dao.UserDaoOracleImpl;
    import com.canso.service.UserServiceImpl;
    
    public class Mytest {
        
        public static void main(String[] args) {
        
            UserServiceImpl userService = new UserServiceImpl();
            userService.setUserDao(new UserDaoImpl());
            userService.getUser();
            userService.setUserDao(new UserDaoOracleImpl());
            userService.getUser();
        }
    }

### IOC本质 ###

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

### HelloSpring ###

编写实体类

package com.canso.pojo;
    
    public class Hello {
        
        private String str;
    
        public String getStr() {
        
            return str;
        }
    
        public void setStr(String str) {
        
            this.str = str;
        }
    
        @Override
        public String toString() {
        
            return "Hello{" +
                    "str='" + str + '\'' +
                    '}';
        }
    }

使用Spring来创建对象，在Spring中对象都称为Bean

<?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
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="hello" class="com.canso.pojo.Hello">
            <property name="str" value="Spring"/>
        </bean>
    </beans>

测试类

import com.canso.pojo.Hello;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Mytest {
        
        public static void main(String[] args) {
        
            //获取Spring的上下文对象~
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            //我们的对象现在都在Spring中管理，我们要使用直接去取即可
            Hello hello = (Hello) context.getBean("hello");
            System.out.println(hello.toString());
        }
    }

**hello对象由Spring创建，hello对象的属性由Spring容器设置，该过程为控制反转**  
控制：谁来控制对象的创建，传统应用程序是由程序本身控制创建的，使用Spring后，对象是由Spring来创建  
反转：程序本身不创建对象，而变成被动接收对象  
依赖注入：就是利用set方法来进行注入的

--------------------

### 对上面“IOC理论推导”的实验进行修改 ###

*  同样创建UserDao、UserService接口以及它的实现类
 *  新建beans.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
            https://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="UserDaoImpl" class="com.canso.dao.UserDaoImpl"/>
        <bean id="UserDaoMysqlImpi" class="com.canso.dao.UserDaoMysqlImpi"/>
    
        <bean id="UserServiceImpl" class="com.canso.service.UserServiceImpl">
            <property name="userDao" ref="UserDaoImpl"/>
        </bean>
        <bean id="UserServiceImpl1" class="com.canso.service.UserServiceImpl">
            <property name="userDao" ref="UserDaoMysqlImpi"/>
        </bean>
    </beans>

*  修改测试类

import com.canso.service.UserServiceImpl;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class Mytest {
        
        public static void main(String[] args) {
        
            //获取Spring的上下文对象~
            ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
            //我们的对象现在都在Spring中管理，我们要使用直接去取即可
            UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
            userServiceImpl.getUser();
            UserServiceImpl userServiceImpl1 = (UserServiceImpl) context.getBean("UserServiceImpl1");
            userServiceImpl1.getUser();
        }
    }

通过new ClassPathXmlApplicationContext(“beans.xml”);获取Spring的上下文对象，在beans.xml中设置对象属性，以及关联关系，之后直接通过Spring的容器getBeans调用。

### Spring配置 ###

*  别名

<alias name="hello" alias="helloNew"/>

*  Bean配置

<bean id="Hello" class="com.canso.pojo.Hello" name="hello2,hello3,hello4">
            <property name="str" value="canso"/>
        </bean>

*  import  
    一般用于团队协作开发，可以将多个配置文件导入一个  
    例子：项目由多人合作开发，每个人负责不同的类开发，需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的

[9ae823686ffd47ee87ccc94d7db14a92.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/9009a71e21834d7cb101e7b07cb20afc.png