Spring（二）

深藏阁楼爱情的钟 2023-07-13 12:16 8阅读 0赞

**使用 spring 的 IOC 解决程序耦合**

*  创建业务层接口和实现类

public interface IAccountDao { 
    	/** * 保存账户 */
    	void saveAccount();
    }

/** * 账户的持久层实现类 */
    public class AccountDaoImpl implements IAccountDao { 
    	@Override
    	public void saveAccount() { 
    		System.out.println("保存了账户");
    	}
    }

*  基于 XML 的配置  
    导入jar包  
    spring-beans-5.1.8.RELEASE.jar  
    spring-context-5.1.8.RELEASE.jar  
    spring-core-5.1.8.RELEASE.jar  
    spring-expression-5.1.8.RELEASE.jar  
    spring-jcl-5.1.8.RELEASE.jar
 *  在类的根路径下创建一个任意名称的 xml 文件（不能是中 文）  
    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">
    </beans>

*  让 spring 管理资源，在配置文件中配置 service 和 dao

<bean id="accountService" class="com.qf.service.impl.AccountServiceImpl">
    </bean>
    
    <bean id="accountDao" class="com.qf.dao.impl.AccountDaoImpl"></bean>

*  测试配置是否成功

/** * 模拟一个表现层 */
    public class Client { 
    	/** * 使用 main 方法获取容器测试执行 * / public static void main(String[] args) { //1.使用 ApplicationContext 接口，就是在获取 spring 容器 ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml"); //2.根据 bean 的 id 获取对象 IAccountService aService = (IAccountService) ac.getBean("accountService"); System.out.println(aService); IAccountDao aDao = (IAccountDao) ac.getBean("accountDao"); System.out.println(aDao); } }

**Spring 基于 XML 的 IOC 细节**

*  spring 中工厂的类结构图  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzM4MDc5_size_16_color_FFFFFF_t_70]
 *  BeanFactory 和 ApplicationContext 的区别
    
    BeanFactory 才是 Spring 容器中的顶层接口。  
    ApplicationContext 是它的子接口。  
    BeanFactory 和 ApplicationContext 的区别：创建对象的时间点不一样。  
    ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。  
    BeanFactory：什么使用什么时候创建对象。
 *  ApplicationContext 接口的实现类
    
    ClassPathXmlApplicationContext：  
    它是从类的根路径下加载配置文件 推荐使用这种  
    FileSystemXmlApplicationContext：  
    它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。  
    AnnotationConfigApplicationContext:  
    当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。

**IOC 中 bean 标签和管理对象细节**

*  bean 标签
    
    作用：  
    用于配置对象让 spring 来创建的。  
    默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
    
    属性：  
    id：给对象在容器中提供一个唯一标识。用于获取对象。  
    class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。  
    scope：指定对象的作用范围。
 *  singleton :默认值，单例的.
 *  prototype :多例的.
 *  request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
 *  session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
 *  global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
    
    init-method：指定类中的初始化方法名称。  
    destroy-method：指定类中销毁方法名称。

**bean 的作用范围和生命周期**

*  单例对象：scope=“singleton”  
    一个应用只有一个对象的实例。它的作用范围就是整个引用。  
    生命周期：  
    对象出生：当应用加载，创建容器时，对象就被创建了。  
    对象活着：只要容器在，对象一直活着。  
    对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
 *  多例对象：scope=“prototype”  
    每次访问对象时，都会重新创建对象实例。  
    生命周期：  
    对象出生：当使用对象时，创建新的对象实例。  
    对象活着：只要对象在使用中，就一直活着。  
    对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

**实例化 Bean 的三种方式**

*  第一种方式：使用默认无参构造函数

<bean id="accountService" class="com.qf.service.impl.AccountServiceImpl"/>

*  第二种方式：spring 管理静态工厂-使用静态工厂的方法创建对象

/** * 模拟一个静态工厂，创建业务层实现类 */
    public class StaticFactory { 
    	public static IAccountService createAccountService(){ 
    		return new AccountServiceImpl();
    	}
    }
    
    <bean id="accountService" class="com.itheima.factory.StaticFactory"
     factory-method="createAccountService"></bean>

*  第三种方式：spring 管理实例工厂-使用实例工厂的方法创建对象

/** * 模拟一个实例工厂，创建业务层实现类 * 此工厂创建对象，必须现有工厂实例对象，再调用方法 */
    public class InstanceFactory { 
    	public IAccountService createAccountService(){ 
    		return new AccountServiceImpl();
    	}
    }
    
    <bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instancFactory"
     factory-method="createAccountService"></bean>

**Spring 的依赖注入(DI)**

*  依赖注入的概念  
    依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。  
    我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。  
    ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。  
    那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。  
    简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
 *  构造函数注入

顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。具体代码如下：
    
    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(name+","+age+","+birthday);
    	}
    }

<bean id="accountService" class="com.qf.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>

*  set 方法注入

顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下：
    /** */
    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(name+","+age+","+birthday);
    	}
    }

<bean id="accountService" class="com.qf.service.impl.AccountServiceImpl">
    <property name="name" value="test"></property>
    <property name="age" value="21"></property>
    <property name="birthday" ref="now"></property>
    </bean>
    <bean id="now" class="java.util.Date"></bean>

*  使用 p 名称空间注入数据（本质还是调用 set 方法）

此种方式是通过在 xml 中导入 p 名称空间，使用 p:propertyName 来注入数据，它的本质仍然是调用类中的set 方法实现注入功能。
    /** * 使用 p 名称空间注入，本质还是调用类中的 set 方法 */
    public class AccountServiceImpl4 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(name+","+age+","+birthday);
    	}
    }

*  注入集合属性

顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。
    我们这里介绍注入数组，List,Set,Map,Properties。具体代码如下：
    public class AccountServiceImpl implements IAccountService { 
    	private String[] myStrs;
    	private List<String> myList;
    	private Set<String> mySet;
    	private Map<String,String> myMap;
    	private Properties myProps;
    	
    	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 setMyProps(Properties myProps) { 
    		this.myProps = myProps;
    	}
    
    	@Override
    	public void saveAccount() { 
    		System.out.println(Arrays.toString(myStrs));
    		System.out.println(myList);
    		System.out.println(mySet);
    		System.out.println(myMap);
    		System.out.println(myProps);
    	}
    }

<bean id="accountService" class="com.qf.service.impl.AccountServiceImpl">
    	
    	
    	
    	<property name="myStrs">
    		<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="testA">aaa</prop>
    			<prop key="testB">bbb</prop>
    		</props>
    	</property>
    	
    	
    	<property name="myProps">
    		<map>
    			<entry key="testA" value="aaa"></entry>
    			<entry key="testB"> <value>bbb</value> </entry>
    		</map>
    	</property>
    </bean>

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzM4MDc5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200311233452284.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM5MzM4MDc5,size_16,color_FFFFFF,t_70