spring基础知识整理

原创 2016年12月06日 19:21:07

spring学习的总结

1、什么是Spring的Ioc容器

spring容器就是常说的Ioc容器,即控制翻转,作为程序员,当我们去实例化一个 对象时,通常需要手动new创建一个对象,并且去跟踪该对象的生命周期,内存分配,内存释放等情况,这样对我们写代码会造成很大不方便,而使用spring容器,spring的实例化new交给容器,我们使用 getBean获取该对象即可,不需要去管理对象。

DI 是指依赖注入,即容器创建对象后,已经处理了对象的依赖关系。

2、依赖注入的两种方式

构造注入


例如,人使用斧子砍柴,则人需要依赖斧子,则在对象人里面存在构造器,

public class People{
    public People(Axe axe) 
    {
    }
}

则文件中配置注解如下

<bean id="people" class="">
    <constructor-arg ref="axe"/>
</bean>

<bean id="axe" class=""/>

设置注入 setter注入


people 类里面存在setAxe()方法

  <bean id="people" class="">
    <property name="axe" ref="axe"/> <!-- set参数名字 axe-->
  </bean>

  <bean id="axe" class=""/>

注解注入 annotation


相关的注解 从 MVC 控制层 - service 层 - Dao 层 - 数据库
ssi中,控制层一般为struts实现,则可以零配置,Dao层提供与单一表的交互,service层则将多个Dao层结合在一起,则此处多用依赖。

service层

 @Service("")  //注明类的名字
  public class MyServiceImpl
  {
    @Autowired       //注入Dao层,利用注解ppDao,必须在注入的类声明一致
    private PeopleDao ppDao;

  }

Dao层

@Repository("ppDao")
public class PeopleDapImpl implements PeopleDa0{}

Dao层一般依赖于sessionFactory,而sessionFactory,可以直接
在文件里面配置即可。

为了让注解生效,需要在文件里面设置,注入context标签

<xmlns:context="http://www.springframework.org/schema/context"/>

<!--哪些包利用注解-->
 <context:component-scan base-package="">
    <context:include-filter type="regex" expression=""/>
    <context:exclude-filter type="regex" expression=""/>
 </context:component-scan>

常用注解
@Component 指定名称的对象
@Service 服务层的组件
@Repository 数据层Dao的组件
@Controller 控制层的组件
@Autowired 注入属性,会从容器中自动查找对象并注入到@Autowired对象上面
@Scope 指定作用域
@Resource 在setter 方法上面定义
@PostConstuct 即定义init-method
@PreDestroy 即定义destroy-method
@Lazy
@DependsOn({“”,”“})

3 spring容器

常用容器BeanFactory为最基本的容器接口,
常用方法
getBean()
containsBean()
getType()

BeanFactory实现类一般为DefaultListableBeanFactory

而applicationContext除了实现BeanFactory接口外,另外实现其他接口

1、事件机制 ApplicationEvent  ApplicationListener
2、message接口
3、资源访问Resource
4、以声明方式启动spring容器 ContextLoaderListener
5、国际化支持
6、bean实现ApplicationContextAware,回调机制获取容器,自动注入spring容器

4、spring中的Bean

1、bean的定义
    所有的bean都被包含在bean下面,我们可以在beans里面定义通用的属性,若在单个bean中再次定义,则可直接覆盖掉。
<beans default-lazy-init="true/false" defult-merge="true/false"
            default-autowire="byType/byName/constuctor/autodetect"
            default-autowire-candidate="com.*.*"
            default-init-method=""
            default-detroy-method="">

2、单个bean声明

<bean id="" class=""/>

3、bean的作用域
singleton、protoType、request、session、global session

4、配置依赖
普通属性 <property name="" value="">
ref指 <property name="" ref="">
自动装配 autowire="byType/byName/constructor/autodetect"
嵌套bean

<property name="">
            <bean class=""/>
        </property>

集合值

        <property name="">
            <set>
                <value/>
                <ref bean=""/>
                <bean class=""/>
            </set>
            <list>
                <value></value>
            </list>
            <map>
                <entry key="" value-ref=""/>
                <entry key="" value=""/>
            </map>
        </property>

5、创建Bean实例
1、直接构造器创建
2、静态工厂构建
<bean id="" class="" factory-method=""/>
3、实例工厂方法

<bean id="BeanFactory" class=""/>
<bean id="" factory-bean="" factory-method=""/>

6、特殊的bean
1、抽象bean,作为模板,一般用作父类,提供公共参数
2、工厂bean,实现FacotyBean的接口,其中getObject为返回所需要的bean
3、bean的回调,实现BeanNameAware

7、Bean的生命周期

    1、创建实例
    2、注入依赖值
    3、实现接口InitializingBean即afterPropertiesSet()
    4、实现init-method
    5、逻辑方法
    6、实现接口DisposableBean 即destroy方法
    7、实现destroy-method方法

8、协同声明周期,即singleton依赖protoType
将singleton的bean的类作为抽象类,protoType对应的字段定义抽象get方法,
则定义singleton的bean时,使用lookup-method方法

public Abstract class People
{
    private Axe axe;
    public Abstract Axe getAxe();
}

public Class iconAxe implements Axe
{
}

<bean id="people" class="">
    <lookup-method name="getAxe" bean=""/>
</bean>
其底层实现,使用动态代理的方法实现。cglib实现抽象类。

9、高级依赖关系配置
1、获取其他bean的属性,即getter方法

<bean id="people" class="">
<property name="son" ref="son"/>
</bean>

获取people中son的属性,使用

<bean id="son2" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">
<property name="targetBeanName" value=""/>
<property name="PropertyPath" value=""/>
</bean>

2、注入其他bean的Field属性

        <bean id="" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
            <property name="targetClass" value=""/>  class类名
            <property name="targetField" value=""/>
        </bean>

3、注入方法返回值

        <bean id="" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">
            <property name="targetObject" ref=""/>
            <property name="targetMethod" value=""/>
            <property name="arguments">  方法执行的参数
                <list>
                    <bean/>
                    <ref/>
                </list>
            </property>
        </bean>

5、AOP,面向切面的编程

5、声明环绕通知
<aop:around> 使用ProceedingJoinPoint joinPoint

定义
public void watch(ProceedingJoinPoint joinPoint)
{
    //前置逻辑
    joinPoint.proceed();    //目标方法执行
    //后置逻辑

}

6、advice传递参数
    在通知中表示参数属性 arg-names
    <aop:before pointcut-ref="" method="" arg-names=""/>
    则参数名字将传递给切面。

7、introduction给对象添加新功能。
    AOP可以实现新功能,相应的可以给目标对象引入新的方法
    若我们对 目标类 people 引入 eat()方法,则只需要定义一个Eater()接口,并且用
    具体的类实现该接口的方法 即可

    <aop:aspect>
        <aop:declare-parents
            type-matching="类"
            implements-interface="接口名"
            default-impl="实现类名"
            />
    </aop:aspect>

    或者用delegate-ref方法引用一个spring bean作为引入的委托
    <aop:aspect>
        <aop:declare-parents
            type-matching="类"
            implements-interface="接口名"
            delegate-ref="id"
            />
    </aop:aspect>
    后者好处可以用来,依赖其他的bean,配置到容器中


8、注解切面

    4中通知一样

    @Aspect
    public class People()
    {
        @PointCut("execution("") && args()")
        注意切点的名称来源于注解所应用的方法名称
        @Before(“切点名称”) After AfterReturning AfterThrowing
        public void applaud()

    }

    然后定义切面bean
    <bean id="people" class=""/>

    为了使切面生效定义
    <aop:aspcetj-autoproxy />,它将在上下文中创建一个AnnotationAwareAspectJAutoProxyCreator类,它会
    自动代理一些bean,这些Bean的方法需要与使用@aspect注解的bean的所定义的切点相匹配,而这些切点是使用
    pointcut注解定义起来的

    引入aop空间
    <xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemalocation=""
    />
    环绕通知
    @Around("方法名")

    标注引入introducing
    <aop:aspect>
        <aop:declare-parents
            type-matching=""
            implements-interface=""
            default-impl=""
            delegate-ref=""/>
    </aop:aspect>

    注解
    @DeclareParents

    @Aspect 注解接口的引入类
    public class InterfaceIntroduce
    {
        @DeclareParents(
        value="目标类名"
        defaultImpl="接口实现方法")

        public Static Interface interface;
    }

    配置文件引入切面AspectJ



    1、before通常定义一个value值,用@Before("execute()")表示切入点

    2、afterReturning需要定义一个切入掉,value或者pointcut,定义一个返回值returning
        @AfterReturning(returning="rvt",pointcut="execute()")
        该rvt可以作为增强方法的参数

    3、afterThrowing需要定义一个切入点(value,pointcut)和throwing
        @AfterReturning(throwing="ex",pointcut="execute()")
        该ex可以作为增强方法的参数Throwable ex 

    4、after不论方法成功与否都会执行增强,只需要定义一个切入点

    5、around的强大
        1、决定方法何时执行 jp.proceed();
        2、改变执行方法的参数  jp.proceed(args);
        3、改变执行方法返回的参数  rt = jp.proceed(args); return rt + "test";
        4、注意线程安全


    6、访问目标对象的方法 通过连接点joinPoint,此时说明增强已经被织入目标方法,通过jp
    可以获取该方法的名字,参数,目标对象
        方法名字:jp.getSignature().getName();
        参数个数:jp.getArgs();
        目标对象:jp.getTarget();

    7、优先级
        同一切面的优先级
        before - around -afterReturning - after
        不同切面的优先级
        1、实现Order()接口
        2、注解@Order(),属性值越小,优先级越高

6、spring的事务

1、事务是什么?
    事务是一个操作序列,要么全部提交,要么全部回退,事务有四个特性,ACID,

2、spring事务策略实现的方法
    spring的事务策略是通过,PlateformTransactionManager接口实现的,对于不同的底层,spring可以配置不同的该接口的实现类,事务策略与事务资源相分离

3、PlateformTransactionManager的方法
        1、TransactionStatus getTransaction(TransactionDefinition definition)
        2、commit(TransactionStatus status)
        3、rollback(status)

4、TransactionDefinition 定义了事务的规则,事务的规则,五角星
        1、事务隔离 isolation 隔离级别
        2、事务超时 timeout
        3、事务可读  readonly    
        4、事务传播  propagation         
        5、回滚规则  rollback  对特定的异常进行回滚 no-rollback

5、TransactionStatus 代表事务本身,提供了控制事务执行和查询事务状态的方法
        1、判断是否为新建的事务 isNewTransaction()
        2、设置事务回滚 setRollbackOnly()
        3、查询事务是否有回滚标志 isRollBackOnly()

6、底层TransactionManager,规则为
        前缀 org.springframework
        类型 jdbc orm transaction等spring的七大组件
        小类为 datasource hibernate4 jta 类名开头
        名字为 DataSourceTransactionManager
            HibernateTransactionManager
            JtbTransactionManager
```
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactory">
                <property name="dataSource" ref=""/>
                <property name="mappingSources" >  <!-- 映射文件 -->
                    <list>
                        <value></value>
                    </list>
                </property>
                <property name="hibernateProperties">
                        <props>
                            <prop key="" value=""/>

                        </props>
                </property>
        </bean>
<bean id="transaction" class="org.springframework.orm.hibernate4.HibernateTransactionManager"   >
<property name="sessionFactory" ref=""/>
</bean>
```


        基于注解的sessionFactory的配置
<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactory">
                    <property name="dataSource" ref=""/>
                    <property name="annotaedClasses" >  <!-- 映射文件 -->
                        <list>
                            <value></value>
                        </list>
                    </property>
                    <property name="hibernateProperties">
                            <props>
                                <prop key="" value=""/>

                            </props>
                    </property>
            </bean>

利用tx进行advice增强,即切面的增强,
定义切面的advice,即事务管理作用的范围,边界

<tx:advice id="txAdvice" transaction-manager="transactionManager">
                <tx:attributes>
                    <tx:method name="get*" read-only="true" rollback-for="" propagation="" isolation="" timout=""/>
                    <tx:method name=""/>
                </tx:attributes>
            </tx:advice>

如何让advice生效,定义一个通知器advisor,在调用该些方法,则调用增强

<aop:config>
    <aop:pointcut id="myPoint" expression="execute(* *.*()) && args()"/>

    <aop:advisor advice-ref="txAdvice" pointcut-ref="myPoint"/>
            </aop:config>

使用注解配置事务

@Transactonal(isolation="" noRollbackFor="" noRoolbackForClassName="" propagation=""readOnly="" rollbackFor="" timeout="")

配置文件启动事务

<bean id="transactionManager"  class="org.springframework.orm.hibernate.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean
<!--注解启动-->
<tx:annotation-driven transaction-manager="transactionManger"/>

<bean id="dataSource"       class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driver">com.mysql.jdbc.Driver</property>
    <property name="url">jdbc:mysql://localhost:3306/数据库名字</property>
    <property name="user"/>
    <property name="password"/>
</bean>

<bean id="sessionFactory" class="">
        <property name="dataSource" ref="dataSource"/>
        <property name="annotatedClasses">
            <list>
                <value>...class</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=

            </value
        </property>
</bean>

<bean id="transactionManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

配置事务增强

<tx:advice id="txAdvice" transaction-manager="transactionManager">
                <tx:attributes>
                    <tx:method name="" 属性配置/>
                </tx:attributes>
</tx:advice>

将advice使用adivsor生效

<aop:config>
                切点
    <aop:pointcut id="" expression="execute()"/>

    <aop:advisor advice-ref="" pointcut-ref=""/>

</aop:config>

7、spring整合struts

    1、spring启动,配置servletContextListener,该监听器可以在web应用启动的时候回调自定义的方法,此时可以启动spring,而spring的ContextLoaderListener配置Listener
    若需要读取多个配置文件,则在web.xml里面定义ContextLocation
<context-param>
                <param-name>contextConfigLocation</param-name>
                <param-value>dao.xml,applicationContext.xml</param-value>
</context-param>

<Listener>
                <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</Listener>

2、使用自动装配,struts的控制组件自动装备service组件。

8、spring整合hibernate

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

spring基础知识汇总及常见面试题目总结

Spring简介 spring框架由Rod Johnson开发,2004年发布了Spring框架的第一版。Spring是一个从实际开发中抽取出来的框架,因此它完成了大量开发中的通用步骤,留给开发...

Spring基础知识汇总——Java开发必看

Spring简介 spring框架由Rod Johnson开发,2004年发布了Spring框架的第一版。Spring是一个从实际开发中抽取出来的框架,因此它完成了大量开发中的通用步骤,留给...

Spring学习笔记1——基础知识

1.在java开发领域,Spring相对于EJB来说是一种轻量级的,非侵入性的Java开发框架,曾经有两本很畅销的书《Expert one-on-one J2EE Design and Devel...
  • chjttony
  • chjttony
  • 2010年11月22日 09:08
  • 42312

Spring知识点总结

在学习Spring之前,先了解Spring是什么。百度百科上解释:Spring是分层的JavaSE/EE full-stack轻量级开源框架,以IoC(Inverse of Control 反转控制)...

spring重点总结

1、首先明白什么叫依赖注入、控制反转,及其作用 控制反转(Inversion of Control ,Ioc) 所谓控制反转就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护由外部容器来...

Spring知识点总结

spring是一个开源的控制反转(IOC)和面向切面(AOP)的容器框架,主要目的就是简化企业开发 spring的依赖注入:在程序运行期间,由外部容器动态的将依赖对象注入到组件中 实例...
  • jaryle
  • jaryle
  • 2016年04月22日 12:30
  • 944

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

spring知识点简明总结

1. 在相同线程中进行相互嵌套调用的事务方法工作于相同的事务中。如果这些相互嵌套调用的方法工作在不同的线程中,则不同线程下的事务方法工作在独立在事务中。 2. 使用Hibernate事务管理器后,可...

Spring框架知识要点总结(第一天)

1.IOC容器创建的2种方式 //首先在applicationContext.xml配置文件中写 //创建方式一: //Spring把所有的配置文件都当做资源 ClassPathResourc...

springMVC知识点学习笔记

一、 springMVC开发框架原理图 其中的组件: 1,前端控制器DispatcherServlet(不需要程序员开发) 作用是接收请求,响应结果,相当于转发器 2,处理器映...
  • jaryle
  • jaryle
  • 2016年05月07日 20:36
  • 974
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:spring基础知识整理
举报原因:
原因补充:

(最多只允许输入30个字)