Spring入门IOC与DI

Spring 入门IOC与DI

Spring 的概念

是java 分层的se/ee的full-stack(一站式)开源框架，为EE的每一层都提供了解决技术:

Spring 的作用

解耦合、声明式事务、集成junit更方便的进行分层测试…

Spring IOC

IOC即控制反转，底层是通过工厂+反射+配置文件来创建对象，解决耦合问题。是一个容器(map)，帮我们管理所有的组件。

Spring 的环境搭建

1. 导包(6个)

   beans、core、context、expression、commons-logging、log4j

   可以只使用commons-logging，但要使用log4j就必须有commons-logging

2. 创建一个实体类

3. 在src下面创建一个配置文件，建议使用applicationContext.xml

   所有约束都抽出来放在一个html文件中/spring-framework-4.2.4.RELEASE/docs/spring-framework-reference/html/xsd-configuration.html

4. 测试

<!-- 
	bean标签: 指定要实例化的对象
		id属性: 唯一标识 可以为任意值 但是整个xml唯一
		class属性: 类的全限定名 就是通过它反射该类的实例对象
		scope属性: 范围，其取值有
			singleton:单实例(默认值)，配置文件加载时，创建该实例对象，使用getBean获取的对象是同一个对象
			prototype:多实例，配置文件加载时不创建对象，使用getBean时创建对象，不是同一个对象
-->
<bean id="user" class="com.edu.domain.User" scope="singleton"></bean>

当用action的时候用多实例，当用servlet、service、dao时用单实例

//通过spring容器获取对象
public void test1() {
	//加载配置文件
	ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
	//通过反射加工厂，获取对象
	User user = (User)context.getBean("user");
	user.say();
}

import标签：导入其他的配置文件

<import resource="..."></import>

Spring 的DI（依赖注入）

1. 什么是DI

   spring在通过ioc创建这个对象的时候,如果这个对象还有属性,就一并给赋值进去,ID是在IOC的基础上进行对象的属性注入

2. DI的属性注入方式(构造器注入、set属性注入、其他方式注入)

   构造器属性注入：条件是对象必须要有构造方法

   <bean id="user" class="com.edu.domain.User" scope="singleton">
   	<constructor-arg name="属性名" value="属性值"></constructor-arg>
   </bean>
   <!-- value:只针对基本类型和String的值进行赋值
   	ref:针对对象 
   -->
   

   set属性的方式：条件是对象的属性必须有set方法

   <bean id="car" class="com.edu.serviceImp.CarImp">
   	<property name="name" value="BMW"></property>
   	<property name="price" value="1500000"></property>
   </bean>
   <!--
    	name:要赋值的属性名
   	value:要赋值的值(针对基本类型和String类型)
   	ref:针对对象类型，其值必须是配置文件中bean的id
   -->
   <bean id="person" class="com.edu.serviceImp.PersonImp">
   	<property name="name" value="jack"></property>
   	<property name="car" ref="car"></property>
   </bean>
   

3. 复杂属性的注入

<!-- 复杂属性的注入 -->
<bean id="coll" class="com.edu.domain.coll">
    <!-- String数组底层是数组 -->
    <property name="ss">
        <list>
            <value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </property>
    <!-- list底层也是数组 -->
    <property name="ll">
        <list>
            <value>l1</value>
            <value>l2</value>
            <!-- 对象类型需要使用ref,并且bean的值必须是配置文件中Bean的id -->
            <ref bean="car"/>
        </list>
    </property>
    <!-- map -->
    <property name="mm">
        <map>
            <entry key="k1" value="v1"></entry>
            <entry key="k2" value="v2"></entry>
            <!-- 当value是对象时，需要用value-ref,并且其值必须是配置文件中Bean的id -->
            <entry key="k3" value-ref="person"></entry>
        </map>
    </property>
    <!-- 键值对类型，通常用来替换配置文件 -->
    <property name="pp">
        <props>
            <prop key="hibernate.root">root</prop>
            <prop key="hibernate.password">123</prop>
        </props>
    </property>
</bean>

spring 整合连接池

<!-- 让spring知道外部的数据库连接信息的配置文件 jdbc.properties,需要导入context的约束 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!-- c3p0数据库连接 -->
<bean id="c3p0" class="com.mchange.v2.c3p0.ComboPooledDataSource">
	<property name="driverClass" value="${jdbc.driver}"></property>
	<property name="jdbcUrl" value="${jdbc.url}"></property>
	<property name="user" value="${jdbc.username}"></property>
	<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- dbcp数据库连接 -->
<bean id="dbcp" class="org.apache.commons.dbcp.BasicDataSource">
	<property name="driverClassName" value="${jdbc.driver}"></property>
	<property name="url" value="${jdbc.url}"></property>
	<property name="username" value="${jdbc.username}"></property>
	<property name="password" value="${jdbc.password}"></property>
</bean>

IOC的注解开发步骤

1. 导包
2. 开启注解扫描器，告诉spring应该去那个包下面解析注解
3. 配置注解组件 Component
4. 测试

@Component("userService")	//定义在类上，注解扫描器一扫描就会创建对象放在spring容器中
//@Scope("singleton")		//声明此类的域，是单实例还是多实例(action需要配置)
public class userServiceImp implements userService {

	@Value("userService")
	private String name;
	@Autowired	//当spring容器中有多个userDao对象时，可以使用@Qualifier("对象的id")来区分
	//也可以使用@Resource(name="对象的id")代替上面两个注解
	private userDao userDao;
	@Override
	public void save() {
		System.out.println(name+"调用了daoImp的存数据方法！");
		userDao.save();
	}
	
	@PostConstruct 	//在对象初始化之后执行的方法
	public void init() {
		System.out.println("初始化之后执行！！！");
	}
	@PreDestroy		//在对象销毁之前执行的方法
	public void destroy() {
		System.out.println("销毁之后执行！！！");
	}
	
}

Spring 整合 junit

1. 导包

   spring-test.jar、spring-aop.jar、junit.jar

2. 告诉spring配置文件的位置

   @ContextConfiguration(value = “classpath:applicationContext.xml”)

3. 告诉spring谁加载配置文件

   @RunWith(value=SpringJUnit4ClassRunner.class)

4. 分层测试

//声明spring配置文件在哪
@ContextConfiguration("classpath:applicationContext.xml")
//声明谁加载配置文件
@RunWith(value=SpringJUnit4ClassRunner.class)	//固定写法
public class SpringJUnitTest {
	
	//当使用SpringJUnit的时候，对象属性不需要写set方法
	@Autowired
	private userService service;
	@Autowired
	private userDao dao;
	
	//可以分层测试
	@Test
	public void Service_save() {
		service.save();
	}
	@Test
	public void Dao_save() {
		dao.save();
	}
}