自己总结的spring(很全)

所谓控制反转就是应用本身不负责依赖对象的创建及维护，依赖对象的创建及维护是由外部容器负责的；

依赖注入(dependency injection):在运行期，由外部容器动态地将依赖对象注入到组件中。好处：

降低组件之间的耦合度，实现软件各层之间的解耦；

可以使用容器提供的众多服务，如，事物管理服务，消息服务等等；

容器提供单例模式支持，开发人员不需要编写实现代码；

提供了AOP技术，利用它很容易实现全线拦截，运行期监控等功能；

容器提供的众多辅助类，使用这些类能够加快开发；

Spring对主流的应用框架提供了集成支持；

需要的jar

dist/spring.jar

lib/jakarata-commons/commons-logging.jar

lib/apectj/aspectjweaver.jar和aspectjrt.jar //使用面向切面编程

lib/cglib/cglib-nodep-2.30_3.jar

lib/j2ee/common-annotations.jar //使用到了注解

spring配置文件模板（帮助文档找）

实力化spring容器常用的两种方式：

方法一：

ApplicationContext ctx=new ClassPathXmlApplicationContext(new String[]{“beans.xml”});

方法二：

ApplicationContext ctx=new FileSystemXmlApplication(new String[]{“d://beans.xml”});

dist/resource/ //下有许多schema配置文件

<bean>中的id属性不能指定特殊的特殊字符，如果有用name属性

实例化对象的方法：

使用静态工厂方法实例化(3.2.3.2.2. Instantiation using a static factory method)

public class PersonServiceBeanFactory {

public static PersonServiceBean createPersonServiceBean(){

return new PersonServiceBean();

}

public PersonServiceBean createPersonServiceBean2(){

return new PersonServiceBean();

}

使用实例工厂方法实例化(3.2.3.2.3. Instantiation using an instance factory method)

<bean id="exampleBean"

factory-bean="serviceLocator"

factory-method="createInstance"/>

singleton(默认)，prototype(getBean方法得到新的bean)（3.4. Bean scopes）

对于scope属性为singleton则spring容器初始化就进行类的实例化而prototype则是getBean时实例化，如果想让singleton也和prototype有一样的行为则在<bean>中写lazy-init=”true”或<beans>中加也行，另外还有一些其他的配置，如：inti-method=””,destroy-method=”” 手动装配

集合类型的注入（3.3.2.4. Collections）

<set>

</set>

</property>

<props>

<prop key=”key1”>value1</prop>

<prop key=”key2”>value2</prop>

<prop key=”key3”>value3</prop>

</props>

<map>

</map>

使用构造器进行注入：见帮助文档

使用Field注入（用于注解方式，。。。。。。。。。。。。）

引入命名空间

xmlns:context=

将连接jdbc.properties文件单独提出来（3.7.2.1. Example: the PropertyPlaceholderConfigurer

）

<value>classpath:com/foo/jdbc.properties</value>

</property>

</bean>

或

<context:property-placeholder location="classpath:com/foo/jdbc.properties"/>

。。。。。。。。。。

<ontext:annotation-config/>

@Autowired默认按类型进行装配

@Resource默认按名称进行装配，当找不到与名称匹配的bean才会按类型装配 @Autowired

Private PersonDao personDao; //如果想使用名称装配可以结合@Qualifier注解 @Autowired @Qualifier(“personDaoBean”)

Private PersonDao personDao;

@Resource(name=”personDaoBean”) //寻找<bean>的id属性为personDaoBean

自动装配

<bean autowire=”byType”

通过在classpath自动扫描方式把组件纳入spring容器中管理

<context:component-scan base-package=””/>

@Component 泛指组件

@Service

@Controller

@Repository 用于标注数据访问组件

这几个注解实际上都一样，spring没有对某个进行特殊的处理

其他常用注解

@Scope 修改Bean的作用域

@PostConstruct 指定init()方法，标注在初始化方法的上

@PreDestory

动态代理

在有接口的情况下

package com.hbjm;

import java.lang.reflect.*;

public class ProxyFactory {

public static Object getProxy(Object targetObject,String user){ return

Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),targetObject.getClass().getInterfaces() , new

MyInvocationHandler(targetObject,user));

} }

无接口用cglib

package com.hbjm;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;

import net.sf.cglib.proxy.MethodInterceptor;

import net.sf.cglib.proxy.MethodProxy;

public class CglibFactory implements MethodInterceptor{

private Object targetObject ;

public Object getProxy(Object targetObject){

this.targetObject=targetObject; return Enhancer.create(targetObject.getClass(),this); //默认会产生一个一targetObject的子类，覆盖所有非final

}

public Object intercept(Object proxy, Method method, Object[] args,

MethodProxy arg3) throws Throwable { System.out.println("您已经被拦截。。。。。。。"); Object result=method.invoke(targetObject, args); return result;

}

Advice前置通知，后置通知，例外通知，最终通知

save()方法执行前，执行后...所执行的方法

Aspect切面，上面所在的类（intercept()方法所在的类）

Joinpoint连接点 save(),update()

Pointcut切入点

Target目标对象

Weave织入

Spring的AOP

加入aop命名空间，引入aop schema文件在xml中加入<aop:aspectj-autoproxy/>配置，这样可以扫描到标注要特殊标注的方@Aspect 定义切面 @Pointcut(“execution(* cn.itcast.servie..*(..))”); 拦截所有的业务方法法和类

execution(java.lang.String cn.itcast.servie..*(java.lang.String,..)) execution(!void cn.itcast.servie..*(..))

//第一个..代表是可以当前包下类，或子包下的类，而第二则是任意数个方法参数

Private void anMethod(){} //声明一个切入点 @Before(”anyMetod() && args(username)”); //前置通知

Public void doAccessCheck(String username){

}

最后将Aspect交给Spring管理

@AfterReturing(pointcut=”anyMethod()”,returning=”result”); //后置通知

Public void doAfterReturing(String result);

//通过注解中的returing属性可以将被拦截方法的返回值注入到该方法的参数上 //其他属性通过尝试来测试 sysout(…………..);

@After(“anyMethod()”); //最终通知

@AfterThrowing(“anyMethod()”) //例外通知

环绕通知：

@Around(“anyMethod()”)

Public Object doBasicProfiling(ProceedingJoinPoint pjp){

Sysout(“进入方法”); Object result=pjp.proceed; Sysout(“退出方法”); Return result;

} //参数为固定写法

基于xml配置方式的声明

<aop:config>

<aop:aspect id=”” ref=””> <aop:pointcut id=”mycut” expression=”execution(*

cn.itast.PersonBean.*(..))”/>

<aop:before point-ref=”mycut method=”doAccessCheck”/>” . . . </aop:aspect>

</aop:config>

Spring+jdbc组合开发

引入commons-dbcp.jar,commons-pool.jar <bean id=”” class=”mons.dbcp.BasicDataSource” destroy-method=”close”></bean>

?useUnicode=true&characterEncoding=UTF-8

采用注解方法配置事物

<bean

er”>

<property name=”dtaSource” ref=”dataSource”/> //采用@Transaction注解方法使用事物 <tx:annotation-driver transaction-manager=”txManager”/> <context:property-placeholder </bean> id=”” class=”org.springframework.jdbc.datasource.DataSourceTransactionManag

location”classpath:jdbc.properties”/>

@Transaction中的属性要注意

事物的传播属性

REQUIRED

业务方法需要在一个事物中运行。如果方法运行时，已经处在一个事物中，那么加入到该事物中，否则为自己创建一个新事物；

NOT_SUPPORTED

声明方法不需要事物；如果事物没有关联到一个事物，容器不会为它开启事物。故国方法在一个事物中被调用，那么该事物会被挂起，在方法调用结束后，原先的事物便会恢复执行； REQUIRESNEW

属性表明不管是否存在事物，业务方法总会认为自己发起一个新事物；如果方法已经运行在一个事物中，则原有你的事物会被挂起，新事物会被创建，直到方法方法执行结束，新事物才算结束，原先的事物才会恢复执行；

MANDATORY

该属性指定业务犯法只能在一个已经存在的事物中执行，业务方法不能发起自己的事物；如果业务方法在没有事物的情况下调用，容器会抛出例外

SUPPORT

在一事物属性表明，如果业务业务方法在某个事物范围内被调用，则方法称为该事物中的一部分，如果方法在事物范围外被调用，则方法在没有事物的环境下执行；

Never

指定业务方法绝对不能在事物范围内执行；如果业务方法在某个事物中执行，则容器会抛出例外，只有业务方法没有关联到任何事物，才能正常执行；

NESTED:

如果一个活动的事物存在，则运行在一个嵌套的事物中，如果没有活动事物，则按REQUIRED属性执行，它使用了个单独的事物，这个事物拥有多个可以回滚的保存点；内部事物的回滚不会对外部事物造成了影响；它只对DataSourceTrasactionManager事物管理器起效 @Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=””) 设置事物为只读属性,提高效率

数据库的隔离级别

基于xml配置事物

<aop:config>

<aop:pointcut id=”” expression=””/> <aop:advisor advice-ref=”txAdvice” pointcut-ref=””/> </aop:cofig> <tx:advice id=” txAdvice” transaction-manager=”txManager”> <tx:attributes> <tx:method name=”get*” read-only=true propagation=”NOT_SUPPORT”>/ <tx:method name=”*”/> </tx:attributes> </tx:advice> Hibernate核心包下的 Hibernate3.jar Lib/required/*.jar Lib/optional/ehche.jar Spring+hibernate+struts整合 Hibernate注解包下的 Lib/test/slf4j-log4j.jar Spring 包下的 Dist/spring.jar

Dist/modules/spring-webmvc-struts.jar

ons-pool.jar

Lib/aspectj/*.jar

Lib/cglib/*jar Lib/Jakarta-comomns/commons-logging.jar,commons-dbcp.jar,comm

Lib/j2ee/commons-anotations.jar Lib/log4j/log4j.jar Struts包下的删除antrl-2.7.2jar避免jar包冲突；把jstl换成1.1版本 Spring和hibernate集成导入包，编写applicationContext.xml,配置datasource和sessionFactory 数据库驱动包配置数据源

</bean>

自己总结的spring很全

Spring和struts

自己总结的spring很全

整合将下列代码放入web.xml

配置ActionServlet

。。。。

（

通过

WebApplicationContext

.getServletContext()); //得到spring容器

）

将struts交给spring管理

将struts-config.xml中的action的path属性和applicationContext.xml中在struts-config.xml配置

自己总结的spring很全

bean的name属性一致 ctx= WebApplicationContextUtils.getWebApplicationContext(this.getServlet()解决struts的乱码问题

<filter-class>org.springframework.web.filter.CharacterEncodingFil <init-param> <param-name>encoding</param-name> <param-value>UTF-8</param-value> ter</filter-class> </inti-param> </filter>

Spring解决延迟加载例外

自己总结的spring很全

<filter> <filter-name>OpenSessionInViewInterceptor</filter-name> <filter-class>org.springframework.orm.hibernate3.support. OpenSessionInViewFilter</filter-class>

</filter>

自动扫描机制，扫描所有的实体类，通过配置包；

将下列代码配置到AnnotationSessionFactoryBean类下

<list>

</list>

</property>

写一个总类的SuperDao注入HibernateTemplate，以后其他类来继承在这个类 HibernateDaoSupport(不重要太麻烦)

只能用xml方式

HibernateTemplate

UserDaoImpl继承自SupportDao，注入HibernateTemplate

注解的处理类在applicationContext.xml中的配置说明：

<context:componet-scan base-package=””/> //处理@component的同类

<aop:aspectj:autoproxy/> //处理@Aspect的同类

<context:annotation-config/> //处理@Resource的同类

关于面向切面：

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.After;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.AfterThrowing;

import

自己总结的spring很全

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Before;

import org.aspectj.lang.annotation.Pointcut;

@Aspect

public class LogInterceptor {

@Pointcut("execution(* com.hbjm.service..*.*(..))") public void anyMethod(){ } //@Before("execution(public void @Before("anyMethod()") public void before(){ } @AfterReturning("anyMethod()") System.out.println("before save....."); com.hbjm.service.impl.PersonServiceImpl.save())")

} public void afterReturn(){ } @AfterThrowing("anyMethod()") public void afterThrowing(){ } @After("anyMethod()") public void after(){ } @Around("anyMethod()") public Object around(ProceedingJoinPoint pjp) throws Throwable{ } System.out.println("arond before...."); Object result=pjp.proceed(); System.out.println("arond after...."); return result; System.out.println("after save...."); System.out.println("afterThrowing save..."); System.out.println("afterReturn save.....");

相关推荐

自己总结的spring(很全)

专栏推荐