Spring总结

spring 7大组成模块：

1:spring core：提供了spring 的核心功能，BeanFactory是spring核心容器的主要组件，它通过Ioc把程序的配置和依赖性与实际的代码分开，是整个spring的基础

2:spring context：通过配置文件向spring提供上下文信息，它构建在BeanFactory之上，另外增加了国际化和资源访问等功能

3:spring dao：提供了一个简单有效的JDBC应用

4:spring aop：提供了面向方面编程的功能 5:spring orm：spring除了有自己的JDBC以外还提供了对其他ORM框架的支持，如Hibernate，都可以和spring进行良好的结合 6:spring web：提供了简化的处理多部分请求以及把请求参数绑定到域的任务。 7:spring MVC：提供了MVC2模式的实现，也可以和struts良好的集成在一起。

这七大模块可以单独使用，不需要其他模块的支持 -------------------------------------------------------- spring的特点： 1：设计良好的分层结构。 2：以IOC为核心，提倡面向接口编程。 3：良好的架构设计。 4：可以代替EJB 5：实现了MVC2 6：可以和其他框架良好的结合如：Hibernate ,struts等编写第一个HelloWorld程序： 1：interface public interface IHelloWorld { public void sayHello(); } 2:实现类： public class HelloWorld implements IHelloWorld{ private String msg; public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } public void sayHello(){ System.out.println(msg); } } 3：编写spring配置文件:applicationContext.xml <beans> <bean id="Hello" class="EnHelloWorld"> <property name="msg"> <value>Hello World!</value> </property> </bean> </beans> 4:编写测试类： public class TestHelloWorld { public static void main(String[] args) { ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml"); IHelloWorld hw= (IHelloWorld)ac.getBean("Hello"); hw.sayHello(); }}

---------------------------------------------------------------------依赖注入的三种方式：1：接口注入2：set注入3：构造注入spring支持set注入和构造注入把上面的HelloWorld改为构造注入： 1：实现类： public class CHelloWorld implements IHelloWorld{ public String msg; public CHelloWorld(String msg){ this.msg = msg; } public void sayHello(){ System.out.print(msg); } } 2：在spring配置文件:applicationContext.xml中： <bean id="CHello" class="CHelloWorld"> <constructor-arg index="0"> <value>C Hello World!</value> </constructor-arg> </bean> constructor-arg 用来表示用构造方式注入参数 index="0"表示是构造方法中的第一个参数

3:编写测试类： public class TestHelloWorld { public static void main(String[] args) { ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml"); IHelloWorld hw= (IHelloWorld)ac.getBean("CHello"); hw.sayHello(); }}

---------------------------------------------------------------------------Spring的核心容器：

spring中两个最基本最重要的包：org.springframework.context和org.springframework.beans为spring的IOC提供了基础在这两个最重要的类是BeanFactory和ApplicationContext。BeanFactory来管理各种bean。ApplicationContext在BeanFactory之上增加了其他功能如国际化，获取资源事件传递等。1：bean的标志(id 和

name) 每个bean都有一个id在管理bean的BeanFactory和ApplicationContext中必须是唯一标志。 id和name都可以用来指定id这两者中至少有一个。区别是id的命名必须符合xml id中和合法字符。name则没有限制，而且可以使用name指定多个id

2：bean的类

class属性路径要完整，包名.类名

3:singleton的使用在spring 中bean可以定义为两种部署模式：singleton和non-singleton singleton：只有一个共享的实例存在 non-singleton：每次请求都创建新的实例

4：bean的属性：在定义bean的属性时除了直接指定bean的属性外还可以参考配置文件中定义的其他bean 1: <bean id="DateHello" class="DateHelloWorld"> <property name="msg"> <value>Hello World!</value> </property> <property name="date"> <bean id="date" class="java.util.Date"/> </property> </bean> 2: <bean id="DateHello" class="DateHelloWorld"> <property name="msg"> <value>Hello World!</value> </property> <property name="date"> <ref bean="date"/> </property> </bean> <bean id="date" class="java.util.Date"/>

5:null值的处理把属性设为null值有两种方法： 1： <bean id="DateHello" class="DateHelloWorld"> <property name="msg"> <value>null</value> </property> </bean> 2: <bean id="DateHello" class="DateHelloWorld"> <property name="msg"> <null/> </property> </bean>

6:使用depends-on

bean的depends-on可以用来在初始化这个bean前，强制执行一个或多个bean的初始化。如： <bean id="DateHello" class="DateHelloWorld" depends-on="date">

---------------------------------------------------------------------------------------

bean的生命周期： 1：bean的定义 //配置bean的开始，beans中包含一个或多个bean <beans> //定义一个bean id是唯一标志，class是bean的来源 <bean id="DateHello" class="DateHelloWorld"> //配置bean的开始 <property name="msg"> <null/> </property> //定义bean的结束 </bean> //配置bean的结束 </beans>2：bean的初始化初始化有两种方式： 1在配置文件中指定init-method属性来完成 public class HelloWorld { private String msg; public void init(){ msg="Hello World"; } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } public void sayHello(){ System.out.println(msg); } } applicationContext.xml文件中 <bean id="DateHello" class="HelloWorld" init-method="init">

2实现org.springframework.beans.factory.InitialingBean接口实现其中的afterPropertiesSet()方法

public class HelloWorld implements InitializingBean{ private String msg; public void afterPropertiesSet(){ msg="Hello World"; } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } public void sayHello(){ System.out.println(msg); } }

applicationContext.xml文件中 <bean id="DateHello" class="HelloWorld"> </bean> 3：bean的使用有三种方式： 1：使用BeanWrapper HelloWorld helloWorld = new HelloWorld (); BeanWrapper bw = new BeanWrapperImpl(helloWorld); bw.setPropertyValue("msg","HelloWorld");

System.out.println(bw.getPropertyValue("msg")); 2:使用BeanFactory InputStream is = new FileInputStream("applicationContext.xml"); XmlBeanFactory factory = new XmlBeanFactory (is); HelloWorld helloWorld = (HelloWorld)factory.getBean ("HelloWorld"); helloWorld.sayHello();

3:使用ApplicationContext ApplicationContext ac = new FileSystemXmlApplicationContext("applicationContext.xml"); IHelloWorld hw= (IHelloWorld)ac.getBean("CHello"); hw.sayHello();

4：bean的销毁销毁有两种方式： 1在配置文件中指定destory-method属性来完成 public class HelloWorld { private String msg; public void init(){ msg="Hello World"; } public void cleanup(){ msg=""; } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } public void sayHello(){ System.out.println(msg); } }

applicationContext.xml文件中 <bean id="DateHello" class="HelloWorld" init-method="init" destory-method="cleanup">

2实现org.springframework.beans.factory.DisposeableBean接口实现其中的destory()方法

public class HelloWorld implements InitializingBean,DisposeableBean{ private String msg; public void afterPropertiesSet(){ msg="Hello World"; } public void destory(){ msg=""; } public String getMsg() { return msg; } public void setMsg(String msg) { this.msg = msg; } public void sayHello(){ System.out.println(msg); } }

applicationContext.xml文件中 <bean id="DateHello" class="HelloWorld"> </bean> ---------------------------------------------------------- 用ref属性指定依赖的三种方式 1：用local属性指定：local属性的值必须与被参考引用的bean的id一致，如果在同一个xml文件里没有匹配的元素，xml解析将产生一个错误如： <bean id="DateHello" class="DateHelloWorld"> <property name="msg"> <value>Hello World!</value> </property> <property name="date"> <ref local="date"/> </property> </bean> <bean id="date" class="java.util.Date"/> 2:用bean属性指定用ref元素中的bean属性指定被参考引用的bean是spring中最常见的形式，它允许指向的bean可以在同一xml文件中也可以不在同一个xml文件里 bean属性的值可以与被引用的bean的id相同也可以与name相同。 <bean id="DateHello" class="DateHelloWorld"> <property name="msg"> <value>Hello World!</value> </property> <property name="date"> <ref bean="date"/> </property> </bean> <bean id="date" class="java.util.Date"/> 3：用parent属性指定用ref元素中的parent属性指定被参考引用的bean时，允许引用当前BeanFactory或ApplicationContext的父BeanFactory或ApplicationContext bean属性的值可以与被引用的bean的id相同也可以与name相同。 <bean id="DateHello" class="DateHelloWorld"> <property name="msg"> <value>Hello World!</value> </property> <property name="date"> <ref parent="date"/> </property> </bean> 用local属性指定和用bean属性指定的比较相同：都可以使用id来参考引用，可以对同一xml文件进行参考引用不同：bean属性的值可以与被引用的bean的id相同也可以与name相同。可以引用不在同一个xml文件里的bean ---------------------------------------------------------- bean自动装配的5种模式：可以使用bean元素的autowire属性来指定bean的装配模式： 1：byName 2: byType 3:constructor 4:autodetect 5:no 显示的指定依赖如：property 和

constructor-arg元素总会覆盖自动装配。对与大型应用不鼓励使用自动装配 -------------------------------------------------------------- bean 依赖检查的4种模式：依赖检查能够分别对每个bean应用或取消应用，默认的是不检查依赖关系，可以使用bean元素的dependency-check属性来指定bean的依赖检查，共有4种： 1：使用simple模式是指对基本类型、字符串和集合进行依赖检查如： <bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="simple"> </bean> <bean id="date" class="java.util.Date"/> 只会对msg进行检查 2：使用object模式是指对对象进行依赖检查如： <bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="object"> </bean> <bean id="date" class="java.util.Date"/> 只会对date进行检查 3：使用all模式是指对所有属性进行依赖检查如： <bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="all"> </bean> <bean id="date" class="java.util.Date"/> 会对msg进行检查和date进行检查 4：使用none模式是指对所有属性不进行依赖检查如： <bean id="DateHello" class="DateHelloWorld" autowire="autodetect" dependency-check="none"> </bean> <bean id="date" class="java.util.Date"/> 不会对msg进行检查和date进行检查总结：一般情况下依赖检查和自动装配结合使用，当bean属性都有默认值或不需要对bean的属性是否被

设置到bean上检查时，依赖检查的作用就不大了 -----------------------------------------------------------------------集合的注入方式对于集合List Set Map Props元素则有不同的配置方式1：List public class HelloWorld{ //定义一个List变量msg List msg=null; public void setMsg(List msg){ this.msg = msg; } } xml文件： <bean id="Hello" class="HelloWorld"> <property name="msg"> <list> <value>Hello World!</value> <value>Hello World2!</value> </list> </property> </bean>

2:set

public class HelloWorld{ //定义一个Set变量msg Set msg=null; public void setMsg(Set msg){ this.msg = msg; } } xml文件： <bean id="Hello" class="HelloWorld"> <property name="msg"> <set> <value>Hello World!</value> <value>Hello World2!</value> </set> </property> </bean>3:map public class HelloWorld{ //定义一个Map变量msg Map msg=null; public void setMsg(Map msg){ this.msg = msg; } } xml文件： <bean id="Hello" class="HelloWorld"> <property name="msg"> <map> <entry key="h1"> <value>Hello World!</value> </entry> <entry key="h2"> <value>Hello World2!</value> </entry> </map> </property> </bean>

4:properties public class HelloWorld{ //定义一个properties变量msg Properties msg; public void setMsg(Properties msg){ this.msg = msg; } } xml文件： <bean id="Hello" class="HelloWorld"> <property name="msg"> <props> <prop key ="h1">Hello World!</prop> <prop key ="h2">Hello

World2!</prop> </props> </property> </bean> --------------------------------------------------------------- Spring AOP(Aspect Oriented Programming) 应用程序通常包含两种代码：一是核心业务代码，一是和业务关系不大的代码如日志、事物处理等。 AOP的思想就是使这两种代码分离，从而降低了两种代码的偶合性，达到了易于重用和维护的目的。 AOP和OOP：在AOP里，每

个关注点的实现并不知道是否有其他关注点关注它，这是AOP和OOP的主要区别，在AOP里组合的流向是从横切关注点到主关注点，在OOP中组合流向是从主关注点到横切关注点。 AOP和OOP所关注的对象不同，AOP是OOP有益的补充，不是对立面。 AOP的3个关键概念： 1：切入点：（PiontCut) 连接点（Jion piont)：是指程序运行中的某个阶段，如方法的调用、异常的抛出等。 PiontCu就是Jion piont点的集合，它是程序中需要注入

的Advice的集合。指明Advice 在什么条件下才被触发。 2：通知（Advice): 某个连接点采用的处理逻辑，也就是向连接点注入的代码。 3：Advisor 是PiontCut和Advice的配置器，它包含PiontCut和Advice，是把Advice注入到PiontCut位置的代码。 Spring 的3种切入点的实现： 1：静态切入点：静态切入点只限于给定的方法和目标类。不考虑方法的参数。 2：动态切入点：动态切入点不仅限于给定的方法和目标类，还可以指定方法的参数。动态切入点有很大的性能损耗，一般很少使用。 3：自定义

切入点：正在发展 Spring 的通知： 1：Intercdption Around通知 Intercdption Around在JiontPoint的前后执行。实现Intercdption Around通知要实现 MethodInterceptor接口，示例代码如下： public class LoginInterceptor implements MethodInterceptor{ public Object invoke(MenthodInvocation invocation) throws Throwable{ System.out.println("开始审核数据"); Object result = invocation.proceed(); System.out.println("审核数据结束"); return result; } } 2:Before通知 Before通知在JiontPoint的前执行。实现Befored通知要实现 MethodBeforeAdvice接口，示例代码如下： public class LoginBeforeAdvice implements MethodBeforeAdvice{ public void Beforee(Menthod m,Object [] atgs,Object target) throws Throwable{ System.out.println("开始审核数据"); } } 3:After Return 通知 After Return通知在JiontPoint后执行。实现After Returnd通知要实现 AfterReturningAdvice接口，示例代码如下： public class LoginAfterAdvice implements AfterReturningAdvice{ public void AfterReturning(Menthod m,Object [] atgs,Object target) throws

Throwable{ System.out.println("审核数据结束"); } } 4:Throw通知 Throw通知在JiontPoint抛出异常时执行。实现Throw通知要实现 ThrowAdvice接口，示例代码如下： public class LoginThrowAdvice implements ThrowAdvice{ public void AfterThrowing(RemoteException ex) throws Throwable{ System.out.println("审核数据异常"); } } 5：Introduction 通知 Introduction通知在JiontPoint 调用完毕后执行。实现Introduction通知要实现 IntroductionAdvisor接口和IntroductionInterceptor接口。用ProxyFactoryBean创建AOP代理使用org.springfamework.aop.framework.ProxyFactoryBean是创建AOP代理的基本方式。 1：使用ProxyFactoryBean代理目标类中的所有方法示例代码： <beans> <bean id="log" class="logAround"/> <bean id="logBefore" class="logBefore"/> <bean id="logAfter" class="logAfter"/> <bean id="logThrow" class="logThrow"/> <bean id="timebook" class="TimeBook"/> <!-设定代理类--> <bean id="logProxy" class ="org.springframework.aop.framework.ProxyFactoryBean">  <property name="proxyInterface"> <value>TimeBookInterface</value> </property>  <property name="target"> <ref bean="timebook"/> </property>  <property name="interceptorNames"> <list> <value>logBefore</value> <value>logAfter</value> <value>logThrow</value> </list> </property> </bean> </beans> 2：使用ProxyFactoryBean代理目标类中的指定方法示例代码： <beans> <bean id="log" class="logAround"/>

<bean id="logBefore" class="logBefore"/> <bean id="logAfter" class="logAfter"/> <bean id="logThrow" class="logThrow"/> <bean id="timebook" class="TimeBook"/>  <bean id ="logAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice"> <ref bean="log"/> </property>  <property name="patterns"> <value>doCheck*</value> </property> </bean> <!-设定代理类--> <bean id="logProxy" class ="org.springframework.aop.framework.ProxyFactoryBean">  <property name="proxyInterfaces"> <value>TimeBookInterface</value> </property>  <property name="target"> <ref bean="timebook"/> </property>  <property name="interceptorNames"> <list> <value>logAdvisor</value> </list> </property> </bean> </beans> --------------------------------------------------------- 正则表达式： 1：.表示可以匹配任何一个字符 2：[]表示只有[]里指定的字符才能匹配 3：*表示匹配次数 4：？表示可以匹配1或0次 5：\是正则表达式的连接符 --------------------------------------------------------------- Spring 中两种AOP代理方式 1:动态代理动态代理是指代理的是接口，Spring默认的是动态代理 2：CGLIB代理 <beans> <bean id="log" class="logAround"/> <bean id="logBefore" class="logBefore"/> <bean id="logAfter" class="logAfter"/> <bean id="logThrow" class="logThrow"/> <bean id="timebook" class="TimeBook"/> <bean id="logProxy" class ="org.springframework.aop.framework.ProxyFactoryBean"> <property name="proxyTargetClass"> <value>true</value> </property> <property name="target"> <ref bean="timebook"/> </property> <property name="interceptorNames"> <list> <value>logBefore</value> <value>logAfter</value> <value>logThrow</value> </list> </property> </bean> </beans>

----------------------------------------------------------------------- Spring 中的自动代理方式自动代理可以跨越多个类，不管哪个类中的方法只要符合要求都可以代理 <beans> <bean id="log" class="logAround"/> <bean id="logBefore" class="logBefore"/> <bean id="logAfter" class="logAfter"/> <bean id="logThrow" class="logThrow"/> <bean id="timebook" class="TimeBook"/> <bean id="timework" class="TimeWork"/>  <bean id="autoProxy" class ="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"/> <bean id="logBeforAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor"> <property name="advice"> <ref bean="logBefore"/> </property> <property name="patterns"> <value>.*do.*</value> </property> </bean> </beans> ------------------------------------------------------------ Spring中的事务处理事务处理是由多个步骤组成，这些步骤之间有一定的逻辑关系，作为一个整体的操作过程，所有的步骤必须同时成功或失败。 1：提交当所有的操作步骤都被完整执行后，称为该事物被提交。 2：回滚由于某个操作失败，导致所有的步骤都没被提交则事物必须回滚，回到事物执行前的状态。事务的特性： ACID：原子性（Atomicity)一致性(Consistency）隔离性（Isolation)持久性(Durablity) Spring中的事务处理是基于动态AOP机制的实

现。 1：编程式事务处理： spring 提供的TransactionTemplate能够以编程的方式实现事务控制。 HelloADO.java: public int create(String msg){ DefaultTransactionDefinition def = new DefaultTransactionDefinition(); TransactionStatus status = transactionManager.getTransaction(def); try{ JdbcTemplate jt = new JdbcTemplate(dataSource); int i=jt.update("insert into st(name,password) values('zz','zz')"); return i; }catch (Exception e){ transactionManager.rollback(status); return 0; } finally { transactionManager.commit(status); } } applicationContext.xml <beans> <bean id ="dataSource" class ="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName"> <value>com.mysql.jdbc.Driver</value> </property> <property name="url"> <value>jdbc:mysql://localhost:3306/newdb</value> </property> <property name="username"> <value>root</value> </property> <property name="password"> <value>lxl</value> </property> </bean> <bean id="transactionManager"