spring总结

Spring的起源：. Spring带来了复杂的J2EE开发的春天。

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

Spring的核心：IOC和AOP IOC: 控制反转或依赖式注入——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

AOP:

面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型

（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

三种实例化Bean的方式： 1.实例化bean的三种方法:

（1）构造器

<property name="personDao" ref="personDao" />

<set>

</set>

</property>

<list>

<value>lists：第一个值</value>

<value>lists：第二个值</value>

<value>lists：第三个值</value>

</list>

</property>

<props>

</props>

</property>

<map>

</map>

</property>

</bean>

（2）静态工厂：

<bean

对应类

public static PersonServiceBean createInstance(){

return new PersonServiceBean();

}

（3）实例工厂：

没有静态方法，因此配置时，先实例化工厂，在实例化需要的bean。

<bean id="personService3" factory-bean="fac" factory-method="createInstance"/> 对应类

public PersonServiceBean createInstance(){

return new PersonServiceBean();

} id="personService2" class="com.persia.PersonServiceBeanFactory" factory-method="createInstance"/>

bean的作用域

默认情况为单例方式：scope=”singleton”

singleton

单实例作用域，这是Spring容器默认的作用域，使用singleton作用域生成的是单实例，在整个Bean容器中仅保留一个实例对象供所有调用者共享引用。单例模式对于那些无会话状态的Bean（如辅助工具类、DAO组件、业务逻辑组件等）是最理想的选择。

prototype

原型模式，这是多实例作用域，针对每次不同的请求，Bean容器均会生成一个全新的Bean实例以供调用者使用。prototype作用域非常适用于那些需要保持会话状态的Bean实例，有一点值得注意的就是，Spring不能对一个prototype Bean的整个生命周期负责，容器在初始化、装配好一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。因此，客户端要负责prototype实例的生命周期管理。

request

针对每次HTTP请求，Spring容器会根据Bean的定义创建一个全新的Bean实例，且该Bean实例仅在当前HTTP request内有效，因此可以根据需要放心地更改所建实例的内部状态，而其他请求中根据Bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的Bean实例将被销毁。该作用域仅在基于web的Spring ApplicationContext情形下有效。

session

针对某个HTTP Session，Spring容器会根据Bean定义创建一个全新的Bean实例，且该Bean实例仅在当前HTTP Session内有效。与request作用域一样，我们可以根据需要放心地更改所创建实例的内部状态，而别的HTTP Session中根据Bean定义创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的Bean实例也会被废弃掉。该作用域仅在基于Web的Spring ApplicationContext情形下有效。

global session

global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的Web应用中才有意义。portlet规范定义了全局Session的概念，它被所有构成某个portlet Web应用的各种不同的portlet所共享。在global session作用域中定义的Bean被限定于全局portlet Session的生命周期范围内。如果我们是在编写一个标准的基于Servlet的Web应用，并且定义了一个或多个具有global session作用域的Bean，系统会使用标准的HTTP Session作用域，并且不会引起任何错误。该作用域仅在基于Web的Spring ApplicationContext情形下有效。

注解方式注入：

@Component 在持久层、业务层和控制层分别采用

@Repository、@Service和@Controller对分层中的类进行注释

@Component对那些比较中立的类进行注释这里就是说把这个类交给Spring管理，重新起个名字，由于不好说这个类属于哪个层面，就用@Component

配置文件中配置AOP

<aop:config>

声明切面 - <aop:aspect id="myaop" ref="aopBean">

声明切入点，指定在某个包下，一个连接点总是代表一个方法的执行。

<aop:pointcut id="mycut" expression="execution(* com..*.*(..))" />

通知类型: 在切面的某个特定的连接点上执行的动作。通知有各种类型，其中包括“around”、

“before”和“after”等通知。

前置通知（Before advice）：在某连接点（join point）之前执行的通知，但这个通知不能阻止连

接点前的执行（除非它抛出一个异常）。

<aop:before pointcut-ref="mycut" method="doBefore" />

抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。

<aop:after-throwing pointcut-ref="mycut" method="doAfterThrowing" />

后通知（After (finally) advice）：当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。

<aop:after pointcut-ref="mycut" method="doAfter" />

环绕通知（Around Advice）：包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

环绕通知是最常用的一种通知类型。

<aop:around pointcut-ref="mycut" method="doAround" />

</aop:aspect>

</aop:config> 注解式声明AOP:

切入点：

@Pointcut("execution (* com.starting.spring.dao.impl.StudentDaoImpl.*(..))")

public void anyMethod(){}

前置通知

@Before("anyMethod() and args(id)")

public void doBefore(int id){ } System.out.println("aop 切入 before 执行"+id);

后置通知

@After("anyMethod()")

public void doAfter(){ System.out.println("aop 切入 after 执行");

}

返回后通知（After returning advice）：在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回

@AfterReturning(pointcut="anyMethod()",returning="result")

public void doAfterReturn(String result){ } System.out.println("aop 切入 after return 执行"+result);

抛出异常后通知（After throwing advice）：在方法抛出异常退出时执行的通知。 @AfterThrowing(pointcut="anyMethod()" ,throwing="ex")

public void doAfterThrowing(Exception ex){ } System.out.println("aop 切入 after throw 执行"); ex.printStackTrace();

环绕通知（Around Advice）：包围一个连接点（join point）的通知，如方法调用。

@Around("anyMethod()") public void doAround(ProceedingJoinPoint pjp ){ } System.out.println("aop 切入 around 方法执行前执行"); }

Spring中配置数据源：

<bean id="dataSource"

加载数据库驱动 class="org.springframework.jdbc.datasource.DriverManagerDataSource">

<property name="driverClassName" value="com.mysql.jdbc.Driver" /> 连接数据库

<propertyname="url"value="jdbc:mysql://localhost:3306/workshop?useUnicode=true&characterEncoding=UTF-8" />

数据库用户名

数据库密码

</bean>

<!--

事务管理类数据源的DataSourceTransactionManager

-->

<bean

ger">

</bean>

- <!-- id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionMana

配置事务管理的方法

--> - <tx:advice id="txAdvice" transaction-manager="txManager"> - <tx:attributes>

拦截以get开头的所有方法

<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED" /> <tx:method name="*" propagation="NOT_SUPPORTED" />

</tx:attributes>

</tx:advice>

- <!--

通过AOP方式，实现事务管理

--> - <aop:config>

拦截在某个包下的某个类中某个方法

拦截的某个类就是切面，而具体的某个方法就是切点

<aop:pointcut id="txcut" expression="execution(*

com.starting.spring.dao..*.*(..))" />

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

</aop:config>

Spring框架项目的总体整合

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

Spring是开源框架，RodJohnson为了解决企业应用开发的复杂性而创建了Spring。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

Spring整合Struts1

1、web.xml配置spring监听

2、spring管理action----name="action的path属性"

3、struts配置action类型为spring代理类

3.2.1 Spring整合Struts1步骤

Spring整合Struts1

第一步：web.xml加入Spring监听，讲解如下配置内容。

<listener-class>

org.springframework.web.context.ContextLoaderListener

</listener-class>

</listener>

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:applicationContext.xml</param-value> </context-param>

第二步：Spring配置Action。

</bean>

注意name属性的用法，在Spring配置文件中加入action的配置 Struts配置Action类型为Spring代理类。

<action attribute="custForm" name="custForm" parameter="method"

path="/cust" scope="request"

type="org.springframework.web.struts.DelegatingActionProxy"> 修改action配置，将其类型改为spring的代理类

AOP思想

4、 Spring上下文中配置AOP

</property>

</bean>

<aop:pointcut id="getm"

expression="execution(* com.qc.service. BankService .get*(..))

and !execution(*com.qc.service.BankService.set*(..))" /> </aop:aspect>

<aop:aspect id="beforeasp" ref="dealwith">

<aop:before pointcut-ref="getm" method="beforeCount" /> </aop:aspect>

<aop:aspect id="afterasp" ref="dealwith">

<aop:after pointcut-ref="getm" method="afterCount" /> </aop:aspect>

</aop:config>

测试Spring AOP

3、Spring上下文中配置事务AOP

</bean>

<aop:config>

<aop:pointcut id="trn"

expression="execution(*

com.qc.iservice.serviceimp.*.save*(..))

or execution(* com.qc.iservice.serviceimp.*.upd*(..)) or execution(* com.qc.iservice.serviceimp.*.del*(..))

or execution(* com.qc.iservice.serviceimp.*.add*(..)) " /> <aop:aspect id="modify" ref="trans">

<aop:around method="guanliTran" pointcut-ref="trn" /> </aop:aspect>

</aop:config>

Spring整合Hibernate

1、数据源---数据库连接属性

2、sessionfactory----hibernate属性和映射文件

3、配置事务机制-----AOP或拦截器

1）配置事务管理类

2）事务策略

3）AOP或拦截机制

Spring上下文中配置dataSource和sessionFactory

Spring上下文中配置dataSource和sessionFactory，舍弃了Hibernate配置文件和Session工具类。

修改BaseDao，添加sessionFaction属性，把sessionFactory注入给各个DAO

<bean id="dataSource"

class="org.springframework.jdbc.datasource.DriverManagerDataSource">

<property name="driverClassName" value="com.mysql.jdbc.Driver" /> <property name="url"

value="jdbc:mysql://localhost:3306/workshop?useUnicode=true&characterEncoding=UTF-8" />

</bean>

<bean id="sessionFactory"

class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<props>

<prop

key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

</props>

</property>

<list>

<value>com/qc/model/Cust.hbm.xml</value>

<value>com/qc/model/Prod.hbm.xml</value>

<value>com/qc/model/Store.hbm.xml</value>

<value>com/qc/model/Precord.hbm.xml</value>

<value>com/qc/model/Dingdan.hbm.xml</value>

<value>com/qc/model/Dmingxi.hbm.xml</value>

</list>

</property>

</bean>

Spring配置声明式事务

<!-- 配置事务管理类

<bean id="txmanager"

class="org.springframework.orm.hibernate3.HibernateTransactionManager">

</bean>

-->

<!-- 事务策略

<tx:advice id="txadvice" transaction-manager="txmanager">

<tx:attributes>

<tx:method name="save*" propagation="REQUIRED" />

<tx:method name="add*" propagation="REQUIRED" />

<tx:method name="upd*" propagation="REQUIRED" />

<tx:method name="del*" propagation="REQUIRED" />

<tx:method name="*" propagation="SUPPORTS" read-only="true"

</tx:attributes>

</tx:advice>

-->

<!-- 事务AOP配置

<aop:config>

<aop:pointcut id="service"

expression="execution(* com.qc.iservice.serviceimp.*.*(..))" /> <aop:advisor advice-ref="txadvice" pointcut-ref="service" />

</aop:config>

-->

</bean>

<props>

<prop key="add*">PROPAGATION_REQUIRED</prop>

<prop key="save*">PROPAGATION_REQUIRED</prop> <prop key="upd*">PROPAGATION_REQUIRED</prop> <prop key="del*">PROPAGATION_REQUIRED</prop>

<prop

key="*">PROPAGATION_REQUIRED,readOnly</prop>

</props>

</property>

</bean>

<bean

class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

<list>

<value>*Service</value>

</list> </property>  <property name="interceptorNames"> <list> <value>transactionInterceptor</value> </list> </property> </bean>

Spring总结

控制反转和依赖注入

一、IOC---控制返转

类的初始化和相互依赖关系转由容器来管理，控制权交给容器处理依赖注入---手段

1、set注入---类里设置set方法 property---set方法名称 ref---注入给该bean的对象

</bean>

dao.setSf(sessionfactory);

2、工厂注入---调用工厂类的静态方法

3、构造注入---类的带参构造

AOP 编程模式及思想

1、切入点---方法

2、切入面----管理切入点的类

3、通知类型----前置、后置、环绕、、、

注意：需要spring容器配置

切入的是spring容器里面的对象方法

SSH整合

（一）Spring整合Struts1

1、web.xml

配置spring监听

2、spring管理action----name="/action的path"

3、struts配置action类型为spring代理类

（二）Spring整合Hibernate

1、数据源---数据库连接属性

2、sessionfactory----hibernate属性和映射文件

3、配置事务机制-----AOP或拦截器

1）配置事务管理类

2）事务策略

3）AOP或拦截机制

相关推荐

spring总结

专栏推荐