spring-ioc一学就会

﹏ヽ暗。殇╰゛Y 2022-12-16 05:55 220阅读 0赞

### spring-ioc ###

*  1.IOC介绍
 *  2.IOC的bean管理
 *   *  2.1 基于xml方式的创建对象
     *   *  2.1.1 基于 xml 方式创建对象
         *  2.1.2 基于 xml 方式注入属性
         *   *  2.1.2.1 第一种注入方式：使用 set 方法进行注入
             *  2.1.2.2 使用有参数构造进行注入
             *  2.1.2.3 注入属性
             *  2.1.2.4 xml 注入集合属性
             *  2.1.2.5 工厂bean的形式注入
             *  2.1.2.6 xml 注入其他类型属性
     *  2.2 基于注解创建对象
     *   *  2.2.1 开启注解
         *  2.2.2 实例化对象
         *  2.2.3 注入对象
 *  3. 实例是单实例还是多实例
 *  4. 生命周期
 *   *  4.1 xml形式
     *  4.2 注解形式
 *  5. 后置处理器
 *  6. 自动装配
 *   *  6.1 xml形式
     *  6.2 注解注入
 *  7. 引入外部资源
 *   *  7.1 xml引入propertise
     *  7.2 注解引入propertise

# 1.IOC介绍 #

1.  IOC的作用是控制反转，把对象创建和对象之间的调用过程，交给 Spring 进行管理
2.  使用 IOC 目的：为了耦合度降低
3.  IOC的原理是使用了xml 解析、工厂模式、反射

# 2.IOC的bean管理 #

Bean管理是指spring**创建对象**和**注入属性**

## 2.1 基于xml方式的创建对象 ##

### 2.1.1 基于 xml 方式创建对象 ###

1.  在 spring 配置文件中，使用 bean 标签，标签里面添加对应属性，就可以实现对象创建
2.  在 bean 标签有很多属性，介绍常用的属性  
            - id 属性：唯一标识  
            - class 属性：类全路径（包类路径）
3.  创建对象时候，默认也是执行无参数构造方法完成对象创建

### 2.1.2 基于 xml 方式注入属性 ###

DI：依赖注入，就是注入属性

#### 2.1.2.1 第一种注入方式：使用 set 方法进行注入 ####

首先创建类，定义属性和对应的 set 方法

/** * 演示使用set方法进行注入属性 */ 
    public class Book {  
        //创建属性 
        private String bname; 
        private String bauthor; 
        //创建属性对应的 set 方法 
        public void setBname(String bname) {  
            this.bname = bname; 
        } 
        public void setBauthor(String bauthor) {  
            this.bauthor = bauthor; 
        } 
    }

然后在 spring 配置文件配置对象创建，配置属性注入

<bean id="book" class="com.spring5.Book"> 
         
        <property name="bname" value="易筋经"></property> 
        <property name="bauthor" value="达摩老祖"></property> 
    </bean>

#### 2.1.2.2 使用有参数构造进行注入 ####

/** * 使用有参数构造注入 */ 
    public class Orders {  
        //属性 
        private String oname; 
        private String address; 
        //有参数构造 
        public Orders(String oname,String address) {  
            this.oname = oname; 
            this.address = address; 
        } 
    }

<bean id="orders" class="com.spring5.Orders"> 
        <constructor-arg name="oname" value="电脑"></constructor-arg> 
        <constructor-arg name="address" value="China"></constructor-arg> 
    </bean>

#### 2.1.2.3 注入属性 ####

外部bean（其实是靠set来赋值的）

<bean id="userService" class="com.spring5.service.UserService"> 
         
        <property name="userDao" ref="userDaoImpl"></property> 
    </bean> 
    <bean id="userDaoImpl" class="com.spring5.dao.UserDaoImpl"></bean>

内部bean（其实是靠set来赋值的）

#### 2.1.2.4 xml 注入集合属性 ####

<bean id="stu" class="com.spring5.collectiontype.Stu"> 
         
        <property name="courses"> 
            <array> 
                <value>java课程</value> 
                <value>数据库课程</value> 
            </array> 
        </property> 
         
        <property name="list"> 
            <list> 
                <value>张三</value> 
                <value>小三</value> 
            </list> 
        </property> 
         
        <property name="maps"> 
            <map> 
                <entry key="JAVA" value="java"></entry> 
                <entry key="PHP" value="php"></entry> 
            </map> 
        </property> 
         
        <property name="sets"> 
            <set> 
                <value>MySQL</value> 
                <value>Redis</value> 
            </set> 
        </property> 
    </bean>

<bean id="course1" class="com.spring5.collectiontype.Course"> 
        <property name="cname" value="Spring5 框架"></property> 
    </bean> 
    <bean id="course2" class="com.spring5.collectiontype.Course"> 
        <property name="cname" value="MyBatis 框架"></property> 
    </bean> 
     
    <property name="courseList"> 
        <list> 
            <ref bean="course1"></ref> 
            <ref bean="course2"></ref> 
        </list> 
    </property>

#### 2.1.2.5 工厂bean的形式注入 ####

1、Spring 有两种类型 bean，一种普通 bean，另外一种工厂 bean（FactoryBean） 
    2、普通 bean：在配置文件中定义 bean 类型就是返回类型 
    3、工厂 bean：在配置文件定义 bean 类型可以和返回类型不一样 
    	第一步 创建类，让这个类作为工厂 bean，实现接口 FactoryBean 
    	第二步 实现接口里面的方法，在实现的方法中定义返回的 bean 类型 
    public class MyBean implements FactoryBean<Course> {  
        //定义返回bean 
        @Override 
        public Course getObject() throws Exception {  
            Course course = new Course(); 
            course.setCname("abc"); 
            return course; 
        } 
        @Override 
        public Class<?> getObjectType() {  
            return null; 
        } 
        @Override 
        public boolean isSingleton() {  
            return false; 
        } 
    }

#### 2.1.2.6 xml 注入其他类型属性 ####

（1）null 值 
     
    <property name="address"> 
        <null/> 
    </property> 
    
    （2）属性值包含特殊符号 
     
    <property name="address"> 
        <value><![CDATA[<<南京>>]]></value> 
    </property>

## 2.2 基于注解创建对象 ##

### 2.2.1 开启注解 ###

<context:component-scan base-package="com.hanlp" use-default- filters="false"> 
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> 
    </context:component-scan> 
     
     
    <context:component-scan base-package="com.hanlp"> 
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> 
    </context:component-scan>

### 2.2.2 实例化对象 ###

（1）@Component 
    （2）@Service 
    （3）@Controller 
    （4）@Repository 
    // 上面四个注解功能是一样的，都可以用来创建bean 实例 
    // 这些注解都是作用在类上，加注在类上后扫描到后会创建默认单例对象

例如：

@Component(value = "userService")  //<bean id="userService" class=".."/> 
    public class UserService {  
        public void add() {  
            System.out.println("service add......."); 
        } 
    }

### 2.2.3 注入对象 ###

1.  @Autowired：根据属性类型进行自动装配

// 第一步 把 service 和 dao 对象创建，在 service 和 dao 类添加创建对象注解 
    // 第二步 在 service 注入 dao 对象，在 service 类添加 dao 类型属性，在属性上面使用注解 
    @Service 
    public class UserService {  
        //定义dao类型属性 
        //不需要添加set 方法 
        //添加注入属性注解 
        @Autowired 
        private UserDao userDao; 
     
        public void add() {  
            System.out.println("service add......."); 
            userDao.add(); 
        } 
    }

1.  @Qualifier：根据名称进行注入

//这个@Qualifier 注解的使用，和上面@Autowired 一起使用 
    //定义dao类型属性 
    //不需要添加set方法 
    //添加注入属性注解 
    @Autowired  //根据类型进行注入 
    @Qualifier(value = "userDaoImpl1") //根据名称进行注入 
    private UserDao userDao;

1.  @Resource：可以根据类型注入，可以根据名称注入

//@Resource //根据类型进行注入 
    @Resource(name = "userDaoImpl1")  //根据名称进行注入 
    private UserDao userDao;

1.  @Value：注入普通类型属性

@Value(value = "abc") 
    private String name;

# 3. 实例是单实例还是多实例 #

在 Spring 里面，默认情况下，bean 是单实例对象

1.  scope设置为singleton的时候为单例，默认的时候就是singleton,加载spring配置的时候就会创建单例对象。
2.  scope设置为prototype的时候为多实例，调用的时候才会创建，每次调用都创建新的实例。  
    eg:注解形式

@Service
    @Scope("prototype")
    public class PersonTemplate {

eg:xml形式

# 4. 生命周期 #

（1）通过构造器创建 bean 实例（无参数构造）  
（2）为 bean 的属性设置值和对其他 bean 引用（调用 set 方法）  
（3）调用 bean 的初始化的方法（需要进行配置初始化的方法）  
（4）bean 可以使用了（对象获取到了）  
（5）当容器关闭时候，调用 bean 的销毁的方法（需要进行配置销毁的方法）

## 4.1 xml形式 ##

public class Orders {  
        //无参数构造 
        public Orders() {  
            System.out.println("第一步 执行无参数构造创建 bean 实例"); 
        } 
        private String oname; 
        public void setOname(String oname) {  
            this.oname = oname; 
            System.out.println("第二步 调用 set 方法设置属性值"); 
        } 
        //创建执行的初始化的方法 
        public void initMethod() {  
            System.out.println("第三步 执行初始化的方法"); 
        } 
        //创建执行的销毁的方法 
        public void destroyMethod() {  
            System.out.println("第五步 执行销毁的方法"); 
        } 
    }

## 4.2 注解形式 ##

@Service
    public class LifeCycleDemo { 
        @PostConstruct
        public void init(){ 
            System.out.println("init");
        }
    
        @PreDestroy
        public void destroy(){ 
            System.out.println("destroy");
        }
    }

# 5. 后置处理器 #

// （1）创建类，实现接口 BeanPostProcessor，创建后置处理器 
    public class MyBeanPost implements BeanPostProcessor {  
        @Override 
        public Object postProcessBeforeInitialization(Object bean, String beanName) 
    throws BeansException {  
            System.out.println("在初始化之前执行的方法"); 
            return bean; 
        } 
        @Override 
        public Object postProcessAfterInitialization(Object bean, String beanName) 
    throws BeansException {  
            System.out.println("在初始化之后执行的方法"); 
            return bean; 
        } 
    }

<bean id="myBeanPost" class="com.spring5.bean.MyBeanPost"></bean>

# 6. 自动装配 #

自动装配是根据指定装配规则（属性名称或者属性类型），Spring 自动将匹配的属性值进行注入

## 6.1 xml形式 ##

<bean id="emp" class="com.spring5.autowire.Emp" autowire="byName"> 
         
    </bean> 
    <bean id="dept" class="com.spring5.autowire.Dept"></bean> 
    
     
     
    <bean id="emp" class="com.spring5.autowire.Emp" autowire="byType"> 
         
    </bean> 
    <bean id="dept" class="com.spring5.autowire.Dept"></bean>

## 6.2 注解注入 ##

参考 2.2

# 7. 引入外部资源 #

## 7.1 xml引入propertise ##

<context:property-placeholder location="classpath:jdbc.properties"/>

## 7.2 注解引入propertise ##

@PropertySource("classpath:jdbc.properties")
    @Configuration
    public class PersonAutoConfiguration {

本文由鹏鹏出品

[更多文章请访问韩利鹏的博客][Link 1]

[Link 1]: https://blog.csdn.net/hanlipenghanlipeng