Springframework基础

1、ApplicationContext容器装配方式

SpringIoc容器的设计主要基于BeanFactory和ApplicationContext两个接口。

1：原始方式基于BeanFactory功能有限

BeanFactory beanFactory = new XmlBeanFactory(new FileSystemResource("D:\\resources\\applicationContext.xml"));

ApplicationContext方式，相对于BeanFactory增加了额国际化、资源访问、时间传播等内容的支持

2：相对路径（推荐方式）

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

3：绝对路径

ApplicationContext context = new FileSystemXmlApplicationContext("D:\\resources\\applicationContext.xml");

4：Web服务器实例化方式

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
         http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0" >
  
  <context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>
      classpath:applicationContext.xml
    </param-value>
  </context-param>
  <listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>
  
</web-app>

实例化ApplicationContext容器的方式：在普通的Java应用当中采用ClassPathXMLApplicationContext类来实例化ApplicationContext容器；在web项目当中则将实例化的工作交给了web服务器。

2、Spring依赖注入方式

1：使用构造方法注入

    <!--在applicationContext文件中配置Bean-->
    <!--被依赖Bean实例-->
    <bean id="userDao" class="com.bbg.dao.impl.UserDaoImpl"></bean>

    <!--构造凡是注入Bean实例-->
    <bean id="testDiService" class="com.bbg.dao.impl.TestDiServiceImpl">
        <constructor-arg index="0" ref="userDao"/>
    </bean>

此时接口使用方式如下：

public class TestDiServiceImpl implements TestDiService {

    private UserDao userDao;

    public TestDiServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void sayHello() {
        this.userDao.sayHello();
    }
}

2：setter方法注入（主流方式）

    <!--被依赖Bean实例-->
    <bean id="userDao" class="com.bbg.dao.impl.UserDaoImpl"></bean>

    <!--setter方法注入-->
    <bean id="testDiService" class="com.bbg.dao.impl.TestDiServiceImpl">
        <property name="userDao" ref="userDao"/>
    </bean>

注意：这种方法TestDiServiceImpl一定要有对应成员变量的setter方法，同时需要有默认的构造函数，否则会抛异常，说没有default constructor fund，因为没有默认构造方法，连类都无法实例化处理啊所以会报错。

3、SpringBean的实例化

Spring框架实例化Bean有三种方式，分别是构造方法实例化、静态工厂实例化和实例工厂实例化。

1：构造方法实例化

Spring框架通过调用Bean的无参构造函数实例化Bean的方式成为构造方法实例化，直接写bean标签的方式就是构造方法实例化

2：静态工厂实例化

工厂只是用来实例化需要的Bean实例的，调用对应的静态方法，实例化需要的Bean。调用静态工厂使用factory-method

// 静态工厂类
public class BeanStaticFactory {
    private static UserDao userDao = new UserDaoImpl();
    
    public static UserDao createUserDao(){
        return userDao;
    }
}

<bean id="staticUserDao" class="com.bbg.bean.BeanStaticFactory" factory-method="createUserDao"/>

3：实例方式实例化

实例工厂和静态工厂不同，需要先把实例工厂Bean构造出来，然后通过实例工厂调用对应实例方法

和静态工厂最大的区别就是需要构造出工厂bean再引用工厂bean的实例方法

// 实例工厂
public class BeanInstanceFactory {
    public UserDao createUserDao(){
        return new UserDaoImpl();
    }
}

    <!--配置工厂-->
    <bean id="instanceFactory" class="com.bbg.bean.BeanInstanceFactory"></bean>
    <!--实例工厂，factory-bean指向对应的工厂，factory-method指向对应构造方法-->
    <bean id="instanceUserDao" factory-bean="instanceFactory" factory-method="createUserDao"></bean>

4、Bean的作用域

在Spring中Bean的作用域包括六种，分别是singleton、prototype、request、session、application、websocket。前两种是最常用很简单，也就是单例和原型。后四种是Web应用中才会用到的，分别表示在一个Http请求中返回同一个Bean实例，在同一个HttpSession当中返回同一个Bean实例，为每一个ServletContext创建一个实例（同一个应用共享一个实例），为每一个WebSocket应用创建一个实例（一个web应用一个实例）。

使用方法：

<bean id="userDao" class="com.bbg.dao.impl.UserDaoImpl" scope="singleton"></bean>

5、Bean的装配

Bean的装配实际上就是依赖注入，将Bean的依赖注入到Spring容器当中。Spring容器支持XML配置的装配，基于注解的装配，以及自动装配等多种装配方式。

1、基于XML的装配

public class ComplexUser {
private String uname;
	private List<String> hobbyList;
	private Map<String,String> residenceMap;
	private Set<String> aliasSet;
	private String[] array;
	private List<User> user;

	/*
	 * 使用构造方法注入，需要提供带参数的构造方法
	 */
	public ComplexUser(String uname, List<String> hobbyList, Map<String, String> residenceMap, Set<String> aliasSet,
			String[] array, List<User> user) {
		super();
		this.uname = uname;
		this.hobbyList = hobbyList;
		this.residenceMap = residenceMap;
		this.aliasSet = aliasSet;
		this.array = array;
		this.user = user;
	}
	/**
	 * 使用setter方法注入，提供默认无参数的构造方法，并为注入的属性提供setter方法
	 */
	public ComplexUser() {
		super();
	}
	public void setUname(String uname) {
		this.uname = uname;
	}
	public void setHobbyList(List<String> hobbyList) {
		this.hobbyList = hobbyList;
	}
	public void setResidenceMap(Map<String, String> residenceMap) {
		this.residenceMap = residenceMap;
	}
	public void setAliasSet(Set<String> aliasSet) {
		this.aliasSet = aliasSet;
	}
	public void setArray(String[] array) {
		this.array = array;
	}
	public void setUser(List<User> user) {
		this.user = user;
	}
}

applicationContext.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">

    <!-- 使用构造方法注入方式装配ComplexUser实例 user1-->
    <bean id="user1" class="assemble.ComplexUser">
    	<constructor-arg index="0" value="chenheng1"/>
    	<constructor-arg index="1">
    		<list>
    			<value>唱歌</value>
    			<value>跳舞</value>
    			<value>爬山</value>
    		</list>
    	</constructor-arg>
    	<constructor-arg index="2">
    		<map>
    			<entry key="dalian" value="大连"/>
    			<entry key="beijing" value="北京"/>
    			<entry key="shanghai" value="上海"/>
    		</map>
    	</constructor-arg>
    	<constructor-arg index="3">
    		<set>
    			<value>陈恒100</value>
    			<value>陈恒101</value>
    			<value>陈恒102</value>
    		</set>
    	</constructor-arg>
    	<constructor-arg index="4">
    		<array>
    			<value>aaaaa</value>
    			<value>bbbbb</value>
    		</array>
    	</constructor-arg>
    	<constructor-arg index="5">
			<list>
				<ref bean="user11"></ref>
			</list>
		</constructor-arg>
    </bean>
    
    <!-- 使用setter方法注入方式装配 ComplexUser实例user2 -->
    <bean id="user2" class="assemble.ComplexUser">
    	<property name="uname" value="chenheng2"/>
    	<property name="hobbyList">
    		<list>
    			<value>看书</value>
    			<value>学习Spring</value>
    		</list>
    	</property>
    	<property name="residenceMap">
    		<map>
    			<entry key="shenzhen" value="深圳"/>
    			<entry key="gaungzhou" value="广州"/>
    			<entry key="tianjin" value="天津"/>
    		</map>
    	</property>
    	<property name="aliasSet">
    		<set>
    			<value>陈恒103</value>
    			<value>陈恒104</value>
    			<value>陈恒105</value>
    		</set>
    	</property>
    	<property name="array">
    		<array>
    			<value>cccccc</value>
    			<value>dddddd</value>
    		</array>
    	</property>
        <property name="user">
			<list>
				<ref bean="user11"></ref>
			</list>
		</property>
    </bean>
</beans>

2、基于注解的装配

• Spring常用注解：
  • @Component
  • @Repository 一般用于Dao层
  • @Service 一般用于服务层
  • @Controller 一般用于控制器组件层
  • @Autowired 自动装配注解（默认根据类型）
  • @Resource 默认按照名称装配，只有找不到对应的Bean才会按照类型装配 包括name和type两个属性
  • @Qualifier 与Autowire搭配使用用于按名称装配

// 需要添加注解
   	<!-- 使用context命名空间，通过Spring扫描指定包下所有Bean的实现类，进行注解解析 -->
	<context:component-scan base-package="annotation"/>