Spring基础知识

Spring是一个IOC(依赖反转Inversion Of Control),DI(依赖注入Dependency Injection)容器AOP

一、三种实例化bean的方式
1.使用类构造器实例化
<bean id=“orderService" class="cn.itcast.OrderServiceBean"/>

 

2.使用静态工厂方法实例化
<bean id="personService" class="cn.itcast.service.OrderFactory" factory-method="createOrder"/>
public class OrderFactory {
 public static OrderServiceBean createOrder(){
  return new OrderServiceBean();
 }
}

3.使用实例工厂方法实例化:
<bean id="personServiceFactory" class="cn.itcast.service.OrderFactory"/>
<bean id="personService" factory-bean="personServiceFactory" factory-method="createOrder"/>
public class OrderFactory {
 public OrderServiceBean createOrder(){
  return new OrderServiceBean();
 }
}

 

二、Bean的作用域
.singleton
 在每个Spring IoC容器中一个bean定义只有一个对象实例。默认情况下会在容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟初始化bean，这时候，只有第一次获取bean会才初始化bean。如：
 <bean id="xxx" class="cn.itcast.OrderServiceBean" lazy-init="true"/>
如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下：
<beans default-lazy-init="true“ ...>
.prototype
 每次从容器获取bean都是新的对象。
 
.request
.session
.global session

 

三、注入依赖对象
基本类型对象注入：
<bean id="orderService" class="cn.itcast.service.OrderServiceBean">
 <constructor-arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入
 <property name=“name” value=“zhao/>//属性setter方法注入
</bean>
注入其他bean：
方式一
<bean id="orderDao" class="cn.itcast.service.OrderDaoBean"/>
<bean id="orderService" class="cn.itcast.service.OrderServiceBean">
 <property name="orderDao" ref="orderDao"/>
</bean>
方式二(使用内部bean,但该bean不能被其他bean使用)
<bean id="orderService" class="cn.itcast.service.OrderServiceBean">
 <property name="orderDao">
  <bean class="cn.itcast.service.OrderDaoBean"/>
 </property>
</bean>

 

 

依赖注入
使用构造器注入
使用属性setter方法注入
使用Field注入（用于注解方式）

1.手工装配依赖对象
 手工装配依赖对象，在这种方式中又有两种编程方式
 a)在xml配置文件中，通过在bean节点下配置
 <bean id="orderService" class="cn.itcast.service.OrderServiceBean">
  <constructor-arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入
  <property name=“name” value=“zhao/>//属性setter方法注入
 </bean>
 b)在java代码中使用@Autowired或@Resource注解方式进行装配。但我们需要在xml配置文件中配置以下信息:
            <context:annotation-config/>这个配置隐式注册了多个对注释进行解析处理的处理器
  在java代码中使用@Autowired或@Resource注解方式进行装配，这两个注解的区别是：@Autowired 默认按类型装配，
  @Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。

@Autowired注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false。如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：
    @Autowired  @Qualifier("personDaoBean")
    private PersonDao  personDao;

2.自动装配依赖对象
 对于自动装配，大家了解一下就可以了，实在不推荐大家使用。例子：
 <bean id="..." class="..." autowire="byType"/>
autowire属性取值如下：

byType：按类型装配，可以根据属性的类型，在容器中寻找跟该类型匹配的bean。如果发现多个，那么将会抛出异常。如果没有找到，即属性值为null。

byName：按名称装配，可以根据属性的名称，在容器中寻找跟该属性名相同的bean，如果没有找到，即属性值为null。

constructor与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。

autodetect：通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。
autodetect-->spring 3.0版本之后已经去掉该值

通过在classpath自动扫描方式把组件纳入spring容器中管理
要使用自动扫描机制，我们需要打开以下配置信息
<context:component-scan base-package="cn.itcast"/>
其中base-package为需要扫描的包(含子包)。

@Service用于标注业务层组件、
@Controller用于标注控制层组件（如struts中的action）、
@Repository用于标注数据访问组件，即DAO组件。
@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注

 

四、集合类型的装配
<bean id="order" class="cn.itcast.service.OrderServiceBean">
    <property name="lists">
          <list>
 <value>lihuoming</value>
         </list>
      </property>  
      <property name="sets">
         <set>
            <value>set</value>
        </set>
      </property>  
     <property name="maps">
        <map>
            <entry key="lihuoming" value="28"/>
       </map>
     </property>  
     <property name="properties">
        <props>
 <prop key="12">sss</prop>
       </props>
      </property>
</bean>

 

二,对象注入的几种方式
注解
@Transactional
@AutoWired(required=false)按类型匹配
@Resource按照名称匹配
@Quanlifier("")制定按照名称匹配
@Controller
@Service
@Repository
@Component
@Scope("prototype"|"single")
@Lazy(true|false)
@PostConstruct
@PreDestory

五、AOP技术-->七大概念，五大通知
1,横切性关注点
2,advice：
前置通知，后置通知，例外通知，最终通知，环绕通知
AOP中的概念
Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.

joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)

Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.

Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知

Target(目标对象):代理的目标对象

Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.

Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Spring提供了两种切面声明方式，实际工作中我们可以选用其中一种：
基于XML配置方式声明切面。
基于注解方式声明切面。
-->基于注解方式声明切面
  开启注解：<aop:aspectj-autoproxy/>
@Aspect
public class LogPrint {
 @Pointcut("execution(* cn.itcast.service..*.*(..))")
 private void anyMethod() {}//声明一个切入点 
 @Before("anyMethod() && args(userName)")//定义前置通知
 public void doAccessCheck(String userName) {
 } 
 @AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知
 public void doReturnCheck(String revalue) {
 }
 @AfterThrowing(pointcut="anyMethod()", throwing="ex")//定义例外通知
    public void doExceptionAction(Exception ex) {
 }
 @After("anyMethod()")//定义最终通知
 public void doReleaseAction() {
 }
 @Around("anyMethod()")//环绕通知
 public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
  return pjp.proceed();
 }
}
-->基于基于XML配置方式声明切面
public class LogPrint {
 public void doAccessCheck() {}定义前置通知
 public void doReturnCheck() {}定义后置通知
    public void doExceptionAction() {}定义例外通知
 public void doReleaseAction() {}定义最终通知
 public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {
  return pjp.proceed();环绕通知
 }
}
<bean id="log" class="cn.itcast.service.LogPrint"/>
<aop:config>
  <aop:aspect id="myaop" ref="log">
   <aop:pointcut id="mycut" expression="execution(* cn.itcast.service..*.*(..))"/>
   <aop:before pointcut-ref="mycut" method="doAccessCheck"/>
   <aop:after-returning pointcut-ref="mycut" method="doReturnCheck "/>
   <aop:after-throwing pointcut-ref="mycut" method="doExceptionAction"/>
   <aop:after pointcut-ref="mycut" method=“doReleaseAction"/>
   <aop:around pointcut-ref="mycut" method="doBasicProfiling"/>
  </aop:aspect>
</aop:config>

 

六、事务的配置方式有两种：注解方式和基于XML配置方式
-->注解方式
采用注解方式
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource" ref="dataSource"/>
  </bean>
 <!– 采用@Transactional注解方式使用事务  -->
  <tx:annotation-driven transaction-manager="txManager"/>

@Service @Transactional
public class PersonServiceBean implements PersonService {
}
-->基于XML配置
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
   <property name="dataSource" ref="dataSource"/>
</bean>
<aop:config>
   <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>
   <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>
</aop:config>
<tx:advice id="txAdvice" transaction-manager="txManager">
   <tx:attributes>
     <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
     <tx:method name="*"/>
   </tx:attributes>
</tx:advice>
事务传播属性：
REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。
NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，在方法调用结束后，原先的事务便会恢复执行。
REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，新的事务会被创建，直到方法执行结束，新事务才算结束，原先的事务才会恢复执行。
MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，容器就会抛出例外。
SUPPORTS：这一事务属性表明，如果业务方法在某个事务范围内被调用，则方法成为该事务的一部分。如果业务方法在事务范围外被调用，则方法在没有事务的环境下执行。
Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，才能正常执行。
NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务， 这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事务造成影响。它只对DataSourceTransactionManager事务管理器起效

数据库系统提供了四种事务隔离级
数据库系统提供了四种事务隔离级别供用户选择。不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，Serializable的隔离级别最高，Read Uncommited的隔离级别最低。大多数据库默认的隔离级别为Read Commited，如SqlServer，当然也有少部分数据库默认的隔离级别为Repeatable Read ，如Mysql
Read Uncommited：读未提交数据(会出现脏读,不可重复读和幻读)。
Read Commited：读已提交数据(会出现不可重复读和幻读)
Repeatable Read：可重复读(会出现幻读)
Serializable：串行化

脏读：一个事务读取到另一事务未提交的更新新据。
不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。
幻读：一个事务读取到另一事务已提交的insert数据。