Spring IOC 和 AOP

IoC(控制反转,(Inversion of Control):本来是由应用程序管理的对象之间的依赖关系,现在交给了容器管理,这就叫控制反转,即交给了IoC容器,Spring的IoC容器主要使用DI方式实现的。

不需要主动查找,对象的查找、定位和创建全部由容器管理 

DI(Dependency Injection) : IOC 的另一种表述方式:即组件以一些预先定义好的方式(例如: setter 方法)接受来自如容器的资源注入. 相对于 IOC 而言,这种表述更直接

1、大量减少了Factory和Singleton的数量,使代码层次更加清晰,主要原因是我们不再查找、定位、创建和管理对象之间的依赖关系了,都交给IoC容器管理了 

2、Spring的IoC容器是一个轻量级的容器,没有侵入性,不需要依赖容器的API,也不需要实现一些特殊接口 

3、一个合理的设计最好尽量避免侵入性 

4、会使我们的框架(Struts和HIbernate)工作的更好 

5、提供了AOP声明式服务能力,可以针对POJO对象提供声明式服务能力,如:声明式事务 

6、对于资源,如Hibernate Session或JDBC Connection我们不在负责开启和关闭 

7、鼓励了我们面向接口编程 

8、减少了代码中的耦合(解耦合),将耦合推迟到了配置文件中,发生了变化也更容易控制

AOP(Aspect-Oriented Programming) 

Cross Cutting Concern : 是一种独立服务,它会遍布在系统的处理流程之中

Aspect:对横切性关注点的模块化

Advice:对横切性关注点的具体实现

Pointcut:它定义了Advice应用到哪些JoinPoint上,对Spring来说是方法调用

JoinPoint:Advice在应用程序上执行的点或时机,Spring只支持方法的JoinPoint,这个点也可以使属性修改,如:Aspecj可以支持

Weave:将Advice应用到Target Object上的过程叫织入,Spring支持的是动态织入

Target Object:Advice被应用的对象

Proxy:Spring AOP默认使用JDK的动态代理,它的代理是运行时创建,也可以使用CGLIB代理

Introduction:可以动态的为类添加方法

AOP配置举例: 

	<aop:config>
		<aop:aspect id="securityAspect" ref="securityHandler">
			<aop:pointcut id="addAddMethod" expression="execution(* add*(..))"/>
			<aop:before method="checkSecurity" pointcut-ref="addAddMethod"/>
		</aop:aspect>
	</aop:config>

   

1. spring bean的作用域 ,scope取值:

    singleton:默认值,每次调用getBean()向IoC容器中取得对象是相同

    prototype:每次调用getBean()向IoC容器中取得对象是不相同

2. 什么是属性编辑器和作用?

   将spring配置文件中的字符串转换成相应的java对象

   spring内置了一些属性编辑器,也可以自定义属性编辑器

3. 如何自定义属性编辑器?

    继承PropertyEditorSupport

    覆盖setAsText()方法

    将自定义的属性编辑器注入到spring中

4.了解关于多配置文件的读取方式

   可以采用数组

   可以采用*匹配模式

5. 如何减少spring的配置文件

   通过<bean>标签将公共的配置提取出来,然后指定<bean>标签中的abstract属性为true,在其他<bean>标签中指定其parent即可

6. spring默认在创建BeanFactory时,将配置文件中所有的对象实例化并进行注入

    但可以采用相关的属性延迟配置文件的初始化,如:default-lazy-init="true"

7. 在web.xml文件中配置ContextLoaderListener,让Web Server在启动的时候将BeanFactory放到ServletContext中    

<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>

    spring的配置文件applicationContext.xml的默认地址在WEB-INF下,只要在web.xml中加入代码 : org.springframework.web.context.ContextLoaderListener , spring

    就会被自动加载。根据Spring框架的API描述,有以下四种方法配置applicationContext.xml文件路径

    1). /WEB-INF/applicationContext.xml

    2). com/config/applicationContext.xml

    3). file:C:/javacode/springdemo/com/config/applicationContext.xml

    4). classpath:com/config/applicationContext.xml

    注:以上路径只是举例,具体使用还是要针对真是项目的。开发过程中,如果spring的配置文件applicationContext.xml未加载的话,一般回报这样的错误 :

         Could not open ServletContext resource [/WEB-INF/applicationContext.xml]

8. 声明式事务配置

    1). 配置SessionFactory

    2). 配置事务管理器

    3). 事务的传播特性

    4). 那些类那些方法使用事务    

9. 编写业务逻辑方法

    1). 继承HibernateDaoSupport类,使用HibernateTemplate来持久化,HibernateTemplate是Hibernate Session的轻量级封装

    2). 默认情况下运行期异常才会回滚(包括继承了RuntimeException子类),普通异常是不会滚的

    3). 编写业务逻辑方法时,最好将异常一直向上抛出,在表示层(struts)处理

    4). 关于事务边界的设置,通常设置到业务层,不要添加到Dao上

10.了解事务的几种传播特性

     1). PROPAGATION_REQUIRED: 如果存在一个事务,则支持当前事务。如果没有事务则开启

     2). PROPAGATION_SUPPORTS: 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行

     3). PROPAGATION_MANDATORY: 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。

     4). PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起。

     5). PROPAGATION_NOT_SUPPORTED: 总是非事务地执行,并挂起任何存在的事务。

     6). PROPAGATION_NEVER: 总是非事务地执行,如果存在一个活动事务,则抛出异常

     7). PROPAGATION_NESTED:如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行

11. Spring事务的隔离级别

      1). ISOLATION_DEFAULT: 这是一个PlatfromTransactionManager默认的隔离级别,使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应

      2). ISOLATION_READ_UNCOMMITTED: 这是事务最低的隔离级别,它充许令外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读,不可重复读和幻像读。

      3). ISOLATION_READ_COMMITTED: 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据

      4). ISOLATION_REPEATABLE_READ:它确保同一事务的多个实例在并发读取数据时,会看到同样的数据行。不过理论上,这会导致另一个棘手的问题:幻读 (Phantom Read)。

                                                            这种事务隔离级别可以防止脏读,不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外,还保证了

                                                            免下面的情况产生(不可重复读)。

      5). ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读,不可重复读外,还避免了幻像读。

12. AOP的实现

      1). 如果目标对象实现了接口,在默认情况下会采用JDK的动态代理实现AOP

      2). 如果目标对象实现了接口,也可以强制使用CGLIB生成代理实现AOP

      3). 如果目标对象没有实现接口,那么必须引入CGLIB,spring会在JDK的动态代理和CGLIB代理之间切换

         CGLIB 需要引入新jar包。

       参考:http://www.xuebuyuan.com/324257.html

13. 如何强制使用CGLIB生成代码?

      加入CGLIB库,SPRING_HOME/lib/cglib/*.jar

      加入如下配置,强制使用CGLIB代理

      <aop:aspectj-autoproxy proxy-target-class="true"/>

14. JDK动态代理和CGLIB代理的区别?

      JDK动态代理对实现了接口的类进行代理

      CGLIB代理可以对类代理,主要对指定的类生成一个子类,因为是继承。我们的目标最好不要使用final声明

15. hibernate 事务查询配置为只读(read-only=true),不会清理缓存,有优化

16. 使用外部属性文件

       Spring 提供了一个 PropertyPlaceholderConfigurer 的 BeanFactory 后置处理器, 这个处理器允许用户将 Bean 配置的部分内容外移到属性文件中. 

       Spring 2.5 之后: 可通过 <context:property-placeholder> 元素简化: <beans> 中添加 context Schema 定义在配置文件中加入如下配置:      

<!-- 导入资源文件 -->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置 C3P0 数据源 -->
<bean id="dataSource"
		class="com.mchange.v2.c3p0.ComboPooledDataSource">
       <property name="user" value="${jdbc.user}"></property>
       <property name="password" value="${jdbc.password}"></property>
       <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
       <property name="driverClass" value="${jdbc.driverClass}"></property>
       <property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
       <property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
</bean>

17. 组件扫描:

     <context:component-scan base-package="com.tgb.web.controller.annotation"> </context:component-scan>   

     特定组件包括(类):

     @Component: 基本注解, 标识了一个受 Spring 管理的组件

     @Respository: 标识持久层组件

     @Service: 标识服务层(业务层)组件

     @Controller: 标识表现层组件

     对于扫描到的组件, Spring 有默认的命名策略: 使用非限定类名, 第一个字母小写. 也可以在注解中通过 value 属性值标识组件的名称

     当在组件类上使用了特定的注解之后, 还需要在 Spring 的配置文件中声明 <context:component-scan> :

     1). base-package 属性指定一个需要扫描的基类包,Spring 容器将会扫描这个基类包里及其子包中的所有类.

     2). 当需要扫描多个包时, 可以使用 逗号分隔.

     3). 如果仅希望扫描特定的类而非基包下的所有类,可使用 resource-pattern 属性过滤特定的类,示例:

          

      4). <context:include-filter> 子节点表示要包含的目标类,<context:exclude-filter> 子节点表示要排除在外的目标类

           <context:component-scan> 下可以拥有若干个 <context:include-filter> 和 <context:exclude-filter> 子节点

18. 使用 @Autowired 自动装配 Bean:

      @Autowired 注解自动装配具有兼容类型的单个 Bean属性。构造器, 普通字段(即使是非 public), 一切具有参数的方法都可以应用@Authwired 注解。默认情况下, 所有使用 @Authwired 注解

      的属性都需要被设置. 当 Spring 找不到匹配的 Bean 装配属性时, 会抛出异常, 若某一属性允许不被设置, 可以设置 @Authwired 注解的 required 属性为 false

      默认情况下, 当 IOC 容器里存在多个类型兼容的 Bean 时, 通过类型的自动装配将无法工作. 此时可以在 @Qualifier 注解里提供 Bean 的名称. Spring 允许对方法的入参标注 @Qualifiter 已指定注入 Bean 的名称

      @Authwired 注解也可以应用在数组类型的属性上, 此时 Spring 将会把所有匹配的 Bean 进行自动装配.

      @Authwired 注解也可以应用在集合属性上, 此时 Spring 读取该集合的类型信息, 然后自动装配所有与之兼容的 Bean. 

      @Authwired 注解用在 java.util.Map 上时, 若该 Map 的键值为 String, 那么 Spring 将自动装配与之 Map 值类型兼容的 Bean, 此时 Bean 的名称作为键值

19. 整合多个配置文件:

      Spring 允许通过 <import> 将多个配置文件引入到一个文件中,进行配置文件的集成。这样在启动 Spring 容器时,仅需要指定这个合并好的配置文件就可以。

      import 元素的 resource 属性支持 Spring 的标准的路径资源

 

配置文件举例: 

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 
 3 <beans xmlns="http://www.springframework.org/schema/beans"
 4          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5          xmlns:aop="http://www.springframework.org/schema/aop"
 6          xmlns:tx="http://www.springframework.org/schema/tx"
 7          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
 8            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
 9            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
10     <!-- 配置SessionFactory -->
11     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
12         <property name="configLocation">
13             <value>classpath:hibernate.cfg.xml</value>
14         </property>
15     </bean>
16     
17     <!-- 配置事务管理器 -->
18     <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
19         <property name="sessionFactory">
20             <ref bean="sessionFactory"/>            
21         </property>
22     </bean>
23     
24     <!-- 那些类那些方法使用事务.两种方式。
25          <aop:config>
26                 <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn.itcast.ssm.service.impl.*.*(..))"/>
27         </aop:config>
28         -->
29     <aop:config>
30         <aop:pointcut id="allManagerMethod" expression="execution(* com.bjpowernode.drp.service.*.*(..))"/>
31         <aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/>
32     </aop:config>
33     
34     <!-- 事务的传播特性 -->    
35     <tx:advice id="txAdvice" transaction-manager="transactionManager">
36         <tx:attributes>
37             <tx:method name="add*" propagation="REQUIRED"/>
38             <tx:method name="del*" propagation="REQUIRED"/>
39             <tx:method name="modify*" propagation="REQUIRED"/>
40             <tx:method name="*" propagation="REQUIRED" read-only="true"/>
41         </tx:attributes>
42     </tx:advice>
43 </beans>

   

   

原文地址:https://www.cnblogs.com/Jtianlin/p/5049650.html