Spring学习笔记（二）

最新推荐文章于 2024-07-08 00:05:07 发布

sena0

最新推荐文章于 2024-07-08 00:05:07 发布

阅读量163

点赞数

分类专栏： Spring 文章标签： Spring

本文链接：https://blog.csdn.net/sonpam/article/details/102881106

版权

Spring 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

SpringIOC

一、IOC的概念和作用

1、IOC即Inversion Of Control，反转控制，就是把创建对象的权利交给框架。
2、IOC的作用是解耦，即削减计算机程序的耦合。

二、使用SpringIOC解耦

1、Spring基于XML的IOC环境搭建和入门
创建配置文件，把配置信息交给Spring，并且获取一个核心容器对象，再根据唯一标志取出Bean对象。
IAccountDao.java

package com.how2java.dao;

public interface IAccountDao {
    public void saveAccount();
}

AccountDaoImpl.java

package com.how2java.dao.impl;

import com.how2java.dao.IAccountDao;

public class AccountDaoImpl implements IAccountDao{
    @Override
    public void saveAccount() {
        System.out.println("保存了账户");
    }
}

IAccountService.java

package com.how2java.service;

public interface IAccountService {
    public void saveAccount();
}

AccountServiceImpl.java

package com.how2java.service.impl;

import com.how2java.dao.IAccountDao;
import com.how2java.dao.impl.AccountDaoImpl;
import com.how2java.service.IAccountService;

public class AccountServiceImpl implements IAccountService{

    private IAccountDao accountDao = new AccountDaoImpl();

    public AccountServiceImpl() {
        System.out.println("对象创建了");
    }

    @Override
    public void saveAccount() {
        accountDao.saveAccount();
    }
}

bean.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
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--把创建对象交给Spring来管理-->
    <bean id="accountService" class="com.how2java.service.impl.AccountServiceImpl"></bean>
    <bean id="accountDao" class="com.how2java.dao.impl.AccountDaoImpl"></bean>
</beans>

Client.java

package com.how2java.ui;

import com.how2java.dao.IAccountDao;
import com.how2java.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 模拟一个表现层，调用业务层
 */
public class Client {
    /**
     * 获取spring的IOC容器，并根据id获取对象
     * @param args
     */
    public static void main(String[] args) {
        //1.获取核心容器对象
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        //2.根据id获取bean对象
        IAccountService as = (IAccountService) ac.getBean("accountService");
        IAccountDao ad = ac.getBean("accountDao", IAccountDao.class);

        System.out.println(as);
        System.out.println(ad);
    }
}

2、BeanFactory和ApplicationContext的区别
Client.java

package com.how2java.ui;

import com.how2java.dao.IAccountDao;
import com.how2java.service.IAccountService;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

/**
 * 模拟一个表现层，调用业务层
 */
public class Client {
    /**
     * 获取spring的IOC容器，并根据id获取对象。
     *
     * ApplicationContext的三个实现类：
     * ①ClassPathXmlApplicationContext,加载类路径下的配置文件；
     * ②FileSystemXmlApplicationContext,加载磁盘任意路径下的配置文件（必须有访问权限）；
     * ③AnnotationConfigApplicationContext,读取注释创建容器的。
     *
     * 核心容器的两个接口引发出的问题：
     * ①ApplicationContext适应单例模式,构建核心容器创建对象时采用立即加载的方式，也就是说，只要读取完配置文件，就创建配置文件中的配置对象。
     * ②BeanFactory适应多例模式，构建核心容器创建对象时采用延迟加载的方式，也就是说，什么时候根据id获取对象，什么时候才创建真正的对象。
     *
     * 实际开发中更常用ApplicationContext接口。
     * @param args
     */
    public static void main(String[] args) {
//        //1.获取核心容器对象
//        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//        //2.根据id获取bean对象
//        IAccountService as = (IAccountService) ac.getBean("accountService");
//        IAccountDao ad = ac.getBean("accountDao", IAccountDao.class);
//
//        System.out.println(as);
//        System.out.println(ad);

        //BeanFactory
        Resource resource = new ClassPathResource("bean.xml");
        BeanFactory factory = new XmlBeanFactory(resource);
        IAccountService as = (IAccountService) factory.getBean("accountService");
        System.out.println(as);
    }
}

三、Spring对bean对象的管理细节

1、创建bean对象的三种方式
IAccountService.java

package com.how2java.service;

public interface IAccountService {
    public void saveAccount();
}

AccountServiceImpl.java

package com.how2java.service.impl;

import com.how2java.service.IAccountService;

public class AccountServiceImpl implements IAccountService{

    public AccountServiceImpl() {
        System.out.println("对象创建了");
    }

    @Override
    public void saveAccount() {
        System.out.println("service中的saveAccount方法执行了");
    }
}

InstanceFactory.java

package com.how2java.factory;

import com.how2java.service.IAccountService;
import com.how2java.service.impl.AccountServiceImpl;

/**
 * 模拟一个工厂类
 * 该类可能存在于一个jar包中
 * 并且无法通过修改源码的方式获取默认构造函数
 */
public class InstanceFactory {

    public IAccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

StaticFactory.java

package com.how2java.factory;

import com.how2java.service.IAccountService;
import com.how2java.service.impl.AccountServiceImpl;

/**
 * 模拟一个工厂类
 * 该类可能存在于一个jar包中
 * 并且无法通过修改源码的方式获取默认构造函数
 */
public class StaticFactory {

    public static IAccountService getAccountService() {
        return new AccountServiceImpl();
    }
}

Client.java

package com.how2java.ui;

import com.how2java.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {

    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as = (IAccountService) ac.getBean("accountService");
        System.out.println(as);
        as.saveAccount();
    }

}

bean.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
        http://www.springframework.org/schema/beans/spring-beans.xsd">
       <!--①使用默认构造函数创建
       配置文件中使用bean标签，并且只有id和class属性，没有其他标签和属性。
       但如果没有默认构造函数，就不能创建bean对象。
   	   -->
   		<bean id="accountService" class="com.how2java.service.impl.AccountServiceImpl"></bean>
   		
		<!--②使用工厂的普通方法创建对象
		       使用某个类中的普通方法创建对象，并存入Spring容器
		-->
    	<bean id="instanceFactory" class="com.how2java.factory.InstanceFactory"></bean>
    	<bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>
    	
		<!--③使用工厂中的静态方法创建对象
        使用某个类中的静态方法创建对象，并存入Spring容器
    	-->
    	<bean id="accountService" class="com.how2java.factory.StaticFactory" factory-method="getAccountService"></bean>

2、bean标签的作用范围

<!--
        bean标签的scope属性用于指定作用范围，取值有：（常用①②）
        ①singleton，（默认）单例；
        ②prototype，多例；
        ③request，作用于web应用的请求范围；
        ④session，作用于web应用的会话范围；
        ⑤global-session，作用于集群环境的会话范围（全局），当不是集群环境时，就是session。
    -->
    <bean id="accountService" class="com.how2java.service.impl.AccountServiceImpl" scope="prototype"></bean>

3、Bean对象的生命周期

<!--
        ①单例对象的生命周期和容器相同。
            出生：当容器被创建时对象出生。
            活着：只要容器还在，对象就活着。
            死亡：容器销毁，对象消亡。
        ②多例对象
            出生：使用对象时Spring创建。
            活着：只要在使用，就一直活着。
            死亡：当对象长时间不用且没有别的对象引用时，调用java的垃圾回收机制。
    -->
    <bean id="accountService" class="com.how2java.service.impl.AccountServiceImpl" scope="prototype" init-method="init" destroy-method="destory"></bean>

四、Spring的依赖注入

1、构造函数注入（不常用）
IAccountService.java

package com.how2java.service;

public interface IAccountService {
    public void saveAccount();
}

AccountServiceImpl.java

package com.how2java.service.impl;

import com.how2java.service.IAccountService;

import java.util.Date;

public class AccountServiceImpl implements IAccountService {

    //经常变化的数据不适用于注入方式
    private String name;
    private Integer age;
    private Date birthday;

    public AccountServiceImpl(String name, Integer age, Date birthday) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    @Override
    public void saveAccount() {
        System.out.println("service的saveAccount方法执行了"+name+","+age+","+birthday);
    }
}

Client.java

package com.how2java.ui;

import com.how2java.service.IAccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Client {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
        IAccountService as = (IAccountService) ac.getBean("accountService");
        as.saveAccount();
    }
}

bean.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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--Spring的依赖注入
        依赖注入：Dependency Injection。
        IOC的作用：降低程序的耦合（依赖关系）。
        依赖关系：交由Spring管理。
        在当前类需要其他类的对象时，由Spring提供，所以只需在配置文件中说明即可。
        依赖注入就是依赖关系的维护。
        能注入的数据有三种：
            ①基本类型和String；
            ②bean类型（在配置文件中或者注解配置过的bean）；
            ③复杂类型/集合类型。
        注入的方式有三种：
            ①使用构造函数提供；
            ②使用setter方法提供；
            ③使用注解提供。
    -->

    <!--构造函数注入（不常用）
        使用的标签：constructor-arg；
        标签使用的位置：bean标签内部；
        标签中的属性：
            type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型。
            index：用于指定要注入的数据给构造函数中指定索引位置的参数赋值，索引的位置是从0开始的。
            name：用于指定给构造函数中指定名称的参数赋值。
            以上三个用于指定给构造函数中哪个参数赋值，常用name。
            value:用于提供基本类型和String类型的数据。
            ref:用于指定其他的bean类型数据，也就是Spring的IOC核心容器中出现过的bean对象。
        优势：获取bean对象时，注入数据是必要操作，否则对象无法成功创建。
        弊端：改变了bean对象实例化方式，在创建对象时，如果用不到这些数据，也必须提供。
    -->
    <bean id="accountService" class="com.how2java.service.impl.AccountServiceImpl">
        <constructor-arg name="name" value="泰勒"></constructor-arg>
        <constructor-arg name="age" value="18"></constructor-arg>
        <constructor-arg name="birthday" ref="now"></constructor-arg>
    </bean>

    <!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>

</beans>

2、setter方法注入
IAccountService.java

package com.how2java.service;

public interface IAccountService {
    public void saveAccount();
}

AccountServiceImpl.java

package com.how2java.service.impl;

import com.how2java.service.IAccountService;

import java.util.Date;

public class AccountServiceImpl implements IAccountService {

    //经常变化的数据不适用于注入方式
    private String name;
    private Integer age;
    private Date birthday;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public void saveAccount() {
        System.out.println("service的saveAccount方法执行了"+name+","+age+","+birthday);
    }
}

bean.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
        http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--2、setter方法注入(常用)
        使用的标签：property
        出现的位置：bean标签内部
        标签中的属性：
            name：用于指定注入时所调用的setter方法名称。
            value:用于提供基本类型和String类型的数据。
            ref:用于指定其他的bean类型数据，也就是Spring的IOC核心容器中出现过的bean对象。
        优势：创建对象时没有明确的限制，可以直接使用默认构造函数。
        劣势：如果有某个成员变量必须有值，那么获取对象时有可能setter方法没有执行。
    -->
    <bean id="accountService" class="com.how2java.service.impl.AccountServiceImpl">
        <property name="name" value="test"></property>
        <property name="age" value="18"></property>
        <property name="birthday" ref="now"></property>
    </bean>
	
	<!--配置一个日期对象-->
    <bean id="now" class="java.util.Date"></bean>

</beans>

3、复杂类型的注入（集合类型的注入）
IAccountService.java

package com.how2java.service;

public interface IAccountService {
    public void saveAccount();
}

AccountServiceImpl.java

package com.how2java.service.impl;

import com.how2java.service.IAccountService;

import java.util.*;

public class AccountServiceImpl implements IAccountService {

    private String[] myString;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String, String> myMap;
    private Properties myProps;

    public void setMyString(String[] myString) {
        this.myString = myString;
    }

    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 setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    @Override
    public void saveAccount() {
        System.out.println(Arrays.toString(myString));
        System.out.println(myList);
        System.out.println(mySet);
        System.out.println(myMap);
        System.out.println(myProps);
    }
}

bean.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
        http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--3、复杂类型的注入（集合类型的注入）
        用于给List结构集合注入的标签：list、array、set；
        用于给Map结构集合注入的标签：map、props；
        结构相同，标签可以互换。
    -->
    <bean id="accountService" class="com.how2java.service.impl.AccountServiceImpl">
        <property name="myString">
            <set>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </set>
        </property>

        <property name="myList">
            <array>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </array>
        </property>

        <property name="mySet">
            <list>
                <value>AAA</value>
                <value>BBB</value>
                <value>CCC</value>
            </list>
        </property>

        <property name="myMap">
            <props>
                <prop key="testC">ccc</prop>
                <prop key="testD">ddd</prop>
            </props>
        </property>

        <property name="myProps">
            <map>
                <entry key="testA" value="aaa"></entry>
                <entry key="testB">
                    <value>bbb</value>
                </entry>
            </map>
        </property>
    </bean>

</beans>