002--spring配置详解

1、beans元素

　　Spring配置文件的根元素，包含一个或多个bean元素

2、bean元素

<bean> 
	id="beanId"（1）
	name="beanName"（2）
	class="beanClass"（3）
	parent="parentBean"（4）
	abstract="true|false"（5）
	singleton="true|false"（6）
	lazy-init="true|false|default"（7）
	autowire="no|byName|byType|constructor|autodetect|?default"（8）
	dependency-check="none|objects|simple|all|default"（9）
	depends-on="dependsOnBean"（10）
	init-method="method"（11）
	destroy-method="method"（12）
	factory-method="method"（13）
	factory-bean="bean">（14）
</bean>

　

（1）、id:Bean的唯一标识名。它必须是合法的XMLID，在整个XML文档中唯一。
（2）、name:用来为id创建一个或多个别名。它可以是任意的字母符合。多个别名之间用逗号或空格分开。
（3）、class:用来定义类的全限定名（包名＋类名）。只有子类Bean不用定义该属性。

（4）、parent:子类Bean定义它所引用它的父类Bean。这时前面的class属性失效。子类Bean会继承父类Bean的所有属性，子类Bean也可以覆盖父类Bean的属性。注意：子类Bean和父类Bean是同一个Java类。
（5）、abstract（默认为”false”）：用来定义Bean是否为抽象Bean。它表示这个Bean将不会被实例化，一般用于父类Bean，因为父类Bean主要是供子类Bean继承使用。
（6）、singleton（默认为“true”）：定义Bean是否是Singleton（单例）。如果设为“true”,则在BeanFactory作用范围内，只维护此Bean的一个实例。如果设为“flase”，Bean将是Prototype（原型）状态，BeanFactory将为每次Bean请求创建一个新的Bean实例。

（7）、lazy-init（默认为“default”）：用来定义这个Bean是否实现懒初始化。如果为“true”，它将在BeanFactory启动时初始化所有的SingletonBean。反之，如果为“false”,它只在Bean请求时才开始创建SingletonBean。
（8）、autowire（自动装配，默认为“default”）：它定义了Bean的自动装载方式。
　　1、“no”:不使用自动装配功能。
　　2、“byName”:通过Bean的属性名实现自动装配。
　　3、“byType”:通过Bean的类型实现自动装配。
　　4、“constructor”:类似于byType，但它是用于构造函数的参数的自动组装。
　　5、“autodetect”:通过Bean类的反省机制（introspection）决定是使用“constructor”还是使用“byType”。
（9）、dependency-check（依赖检查，默认为“default”）：它用来确保Bean组件通过JavaBean描述的所以依赖关系都得到满足。在与自动装配功能一起使用时，它特别有用。
　　1、none：不进行依赖检查。
　　2、objects：只做对象间依赖的检查。
　　3、simple：只做原始类型和String类型依赖的检查
　　4、all：对所有类型的依赖进行检查。它包括了前面的objects和simple。

（10）、depends-on（依赖对象）：这个Bean在初始化时依赖的对象，这个对象会在这个Bean初始化之前创建。
（11）、init-method:用来定义Bean的初始化方法，它会在Bean组装之后调用。它必须是一个无参数的方法。
（12）、destroy-method：用来定义Bean的销毁方法，它在BeanFactory关闭时调用。同样，它也必须是一个无参数的方法。它只能应用于singletonBean。
（13）、factory-method：定义创建该Bean对象的工厂方法。它用于下面的“factory-bean”，表示这个Bean是通过工厂方法创建。此时，“class”属性失效。
（14）、factory-bean:定义创建该Bean对象的工厂类。如果使用了“factory-bean”则“class”属性失效。

 

以下讲解依赖注入，即配置bean组件实例化时需要用的参数

2.1、constructor-arg元素

构造方法注入

<constructor-arg index="参数索引" ref="bean组件id"/>　

2.2、 property元素

setter方式

基本类型值的注入格式：

 <property name="属性名">
	<value>值</value>
 </property>

Bean对象的注入格式：

<property name="属性名" ref="bean组件id"></property>

其他类型参数注入格式：

<!-- 	private List<String> citys; -->
<property name="citys">
	<list>
		<value>北京</value>
		<value>上海</value>
		<value>深圳</value>
	</list>
</property>

　　

<!-- private Set<String> friends;  -->
<property name="friends">
	<set>
		<value>张三</value>
		<value>李四</value>
		<value>王五</value>
	</set>
</property>

　　

<!-- private Map<Integer,String> books; -->
<property name="books">
	<map>
		<entry key="10" value="CoreJava"></entry>
		<entry key="11" value="JavaWeb"></entry>
		<entry key="12" value="SSH2"></entry>
	</map>
</property>

　　

<!-- private Properties props; -->
<property name="props">
	<props>
		<prop key="url">http://www.tom.com</prop>
		<prop key="username">zhangsan</prop>
		<prop key="password">123456789</prop>
	</props>
</property>

　

3、aop:config元素

<aop:config>
　　<!-- 定义切入点,指定那个范围使用 -->
　　<aop:pointcut id="id标识" expression="切入点表达式"/>

　　<!-- 记录操作日志 -->
　　<aop:aspect id="loggeraspect" ref="loggerbean">
　　　　<!-- 采用环绕通知切入 -->
　　　　<aop:around pointcut-ref="daocut"  method="optLogger"/>
　　</aop:aspect>

　　<!-- 记录异常信息日志 -->
　　<aop:aspect id="exceptionaspect"  ref="exceptionloggerbean">
　　　　<!-- 采用异常通知切入,把异常对象传给ex参数 -->
　　　　<aop:after-throwing pointcut-ref="daocut" method="exceptionLogger" throwing="ex"/>
　　</aop:aspect>

</aop:config>

3.1、介绍

a.切面(Aspect)
　　封装了共通处理的组件,可用于切入到目标对象的处理方法中
b.切入点(Pointcut)
　　用于指定目标对象和方法的一个表达式.是连接点的集合.
　　连接点是切面组件与某一个目标对象方法的作用点,例如方法调用和异常发生
c.通知(Advice)
　　用于指定切面功能切入目标对象方法的位置.例如切入到目标方法调用之前,目标方法调用之后等.
　　通知类型:前置通知,后置通知,环绕通知,最终通知,异常通知
　　try{
　　　　//执行前置通知<aop:before>
　　　　//执行环绕通知--前置<aop:around>
　　　　　执行目标对象方法
　　　　//执行环绕通知--后置
　　　　//执行后置通知<aop:after-returnning>
　　}catch(Exception ex){
　　　　//执行异常通知<aop:after-throwing>
　　}finally{
　　　　//执行最终通知<aop:after>
　　}

d.目标对象(Target)
　　需要使用切面功能的,被切入的Bean对象.使用切入点表达式指定
e.动态代理(AutoProxy)
　　在Spring采用了AOP之后,从容器取出的目标对象是一个动态代理类型,调用代理对象方法时,代理对象会调用切面功能和目标对象功能.
　　动态代理类生成技术:
　　有接口的目标对象采用JDK Proxy技术.
　　没有接口的目标对象采用CGLIB技术.

3.2、切入点表达式的定义

　　1)方法限定execution
　　　　execution(modifier-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

　　　　上面的格式中，execution是不变的，用于作为execution表达式的开头，整个表达式中几个参数的详细解释如下：
　　　　modifier-pattern：指定方法的修饰符，支持通配符，该部分可以省略
　　　　ret-type-pattern：指定返回值类型，支持通配符，可以使用“*”来通配所有的返回值类型
　　　　declaring-type-pattern：指定方法所属的类，支持通配符，该部分可以省略
　　　　name-pattern：指定匹配的方法名，支持通配符，可以使用“*”来通配所有的方法名
　　　　param-pattern：指定方法的形参列表，支持两个通配符，“*”和“..”，其中“*”代表一个任意类型的参数，而“..”代表0个或多个任意类型的参数。
　　　　throw-pattern：指定方法声明抛出的异常，支持通配符，该部分可以省略

　　　　a.匹配com.cft.UserDAO的save()方法
　　　　　　execution(* com.cft.UserDAO.save(..))
　　　　b.匹配com.cft.UserDAO的所有方法
　　　　　　execution(* com.cft.UserDAO.*(..))
　　　　c.匹配com.cft.UserDAO的所有public void方法
　　　　　　execution(public void com.cft.UserDAO.*(..))
　　　　d.匹配com.cft包下所有类型的所有方法
　　　　　　execution(* com.cft.*.*(..))
　　　　e.匹配com.cft包下及其子包所有类型的所有方法
　　　　　　execution(* com.cft..*.*(..))
　　　　f.匹配UserDAO中有一个参数并且是String类型的方法
　　　　　　execution(* com.cft.UserDAO.*(java.lang.String))

　　2)类型限定within
　　　　within(类型)
　　　　a.匹配com.cft.UserDAO的所有方法
　　　　　　within(com.cft.UserDAO)
　　　　b.匹配com.cft包下的所有类的所有方法
　　　　　　within(com.cft.*)
　　　　c.匹配com.cft包下及其子包的所有类的所有方法
　　　　　　within(com.cft..*)
　　3)id名限定bean
　　　　bean(idOrName属性值)
　　　　a.匹配容器中所有id或name属性值以dao结尾的bean对象
　　　　　　bean(*dao)

　

4、context:component-scan元素

组件自动扫描　

<context:component-scan base-package="包路径">

如果发现包中的类,类定义前面有以下注解,将纳入spring容器,id名默认采用类名(首字母小写).
　　@Controller :扫描控制层组件的注解标记,例如Action
　　@Service :扫描业务层组件的注解标记,例如Service
　　@Repository :扫描数据访问层组件的注解标记,例如DAO
　　@Component :其他组件
如果需要自定义id名,可以采用@Controller("id自定义名")
属性注入注解
　　在变量定义前,使用@Resource注解标记,spring默认会采用类型匹配原则将符合的bean对象注入进来.如果按指定id名注入bean对象,可以使用
　　@Resource(name="bean对象的id名").
　　注入还可以使用@Autowired,如果需要注入指定名的bean对象.
　　@Autowired
　　@Qualifier("hibernateUserDAO")
注意:setter方法可以不写,将来spring自动生成.
其他注解
　　@Scope("prototype")//等价于<bean scope="prototype">
　　@PostConstruct//等价于<bean init-method>
　　@PreDestroy//等价于<bean destroy-method>