标签：
Spring
ApplicationContext 正是spring容器
创建ApplicationContext
ApplicationContext ctx=new ClassPathXmlApplication(“bean.xml”);
public class PersonService{
pivate String name;
set get 方法
}
bean.xml
<bean id =”personService” class=”cn.my.PersonService”>
<property name=”name” value= “wawa” />
</bean>
在主函数中
PersonService p= ctx.getBean(“personService”,”PersonService.class”);
System.out.println(p.getName()); //打印结果为wawa
由spring容器创建实例并设置属性的方式称为控制 反转IOC或者依赖注入
当一个java实例(调用者)需要另外一个java实例(被调用者),通常由调用者创建被调用者的实例,被调用者注入到调用者里面
采用依赖注入,不需要使用New关键字来创建对象,达到解耦和的目的
IOC容器通过set方法(设值注入)或者构造器注入(构造注入)容器
spring容器是创建bean的工厂,并关联bean
spring有两个核心接口ApplicationContext(spring上下文) 和BeanFactory 前者是后者的子接口
BeanFactory接口的方法:
boolean containsBean(Stirng name) 判断是否包含bean
Object getBean(String name) 得到bean
<T> T getBean(Sting name, Class requiredType) 返回id为name 类型为requiredType 的bean
Class<?> getType(String name) 获得指定bean的类型
他有一个常用的实现类 XmlBeanFactory
对应大部分程序使用beanFactory 的子接口ApplicationContext更为方便
ApplicatioinContext常用实现类有 ClassPathXmlApplicationContext //加载class 路径下的配置文件
FileSystemXmlApplicationContext//加载基于 系统路径下的文件
XmlWebApplicationContext
AnnotationConfigWebApplicationContext
web应用常用后两个
XML配置文件通常通过Resource对象传入
对于大部分javaee应用程序,启动时会自动创建ApplicationContext,无需自己手动创建来.
当然也可以手动创建
可以加载多个配置文件
ApplicationContext ctx= new ClassPathXmlApplicationContext( new String[]{“bean.xml”,”bean2.xml”});
ApplicationContext 在被系统创建时会,会初始化所有的singleton bean ,因此会有很大的开销,但一旦初始化完成,会有很好的性能
1.spring的国际化
ApplicationContext接口继承MessageSource接口,具有国际化功能 ,用于国际化的方法是getMessage( String code,Object[] args ,Locale loc)
会自动查找名为messageSource的bean
<bean id=” messageSource” class=””>
<property name=”basenames”>
<list>
<value> message</value>
</list>
</property>
</bean>
message.properties//中文资源文件
hello=欢迎你,{0}
now=现在时间是:{0}
message_en_US.properties//美式英语资源文件
hello=welcome.{0}
now=now is:{0}
主函数中:
Object[] a={“读者”};
String hello= ctx.getMessage(“hello”,a,Locale.getDefault());
system.out.println(hello);//输出为 欢迎你,读者
2.ApplicationContext的事件机制
是观察者设计模式的实现
两个重要接口ApplicationEvent 容器事件
ApplicationListener 监听器
事件机制: 事件源 事件 事件监听器
事件监听器要配置bean
3.
在实际开发中在web.xml文件中配置spring容器的监听器,完成spring 容器的初始化,因此不必主动访问spring容器
如果通过bean想获得容器,那么这个bean可以实现 ApplicationContextAware接口
该接口有个方法 set ApplicationContext() 和getApplicationContext()
4.1配置
<beans >
<bean id= class= >
</bean>
</beans>
4.2bean的作用域
bean有5中作用域
singleton: 单例模式 整个spring容器中只有该bean的一个实例
prototype: 多例 ,每次通过getBean获取bean后创建一个新的实例
request : 每次http请求都会产生一个新的bean
session :每次 http session都会产生新的实例
系统默认的是单例模式
<bean id = class = scope=”prototype”>
request和ssesion bean作用域需要配置以后才可以生效 ,配置 listerner或者fliter
4.3 bean的依赖注入
两种: <property > setter注入
<constructor-tag> //构造器注入
注入普通属性:
<property name =”” value =””/>
注入bean类型的属性
<property name= “” ref=”” />
自动装配: <bean id=”” class=”” autowire=”byName | byType” >
需要提供setter方法
嵌套注入bean
<bean id class >
<bean id class />
</bean>
里面的这个bean无法直接通过容器访问
集合 map的注入
<bean>
<property>
<list>
<value>
</value>
</list>
</property>
</bean>
<map >
<entry key=”” value=”” />
<entry/>
</map>
@Configuration //在类上声明
@Value//在属性上声明 注入的是一个属性值
@Bean //在方法上声明 注入的是方法返回的bean
@Scope修饰方法,指明bean的生命域
开发项目中可以xml配置和注解配置结合使用,因为注解配置出现的比较晚, 功能没有XML强大
1)如果以xml为主.注解注入为辅
则需要在配置文件里面 加入 <context:annotation-config />
2)如果以注解为主
@Configuration
@ImportResource(“classpath:/bean.xml”)
6.bean实例的创建方式
构造器创建bean实例
系统默认的是该方式 bean类提供无参的构造方法
<bean id class>
使用静态工厂方法创建bean实例
interface Being{}
public class Dog implements Being{}
public class BeingFactory{
private String msg;
public static Being getBeing(String arg)
{
if (arg.equals(“dog”))
{
return new Dog();
}
}
}
<bean id=”dog” class =” cn.my.BeingFactory” factory-method=”getBeing”>
<property name=”msg” value=”我是狗”>
<constructor-arg value=”dog” />
</bean>
调用实例工厂方法创建bean
<bean id class factory-bean factory-method>
7.深入理解bean
抽象bean 不能实例化,一般用来被继承,用作bean模版
子bean配置
<bean id=”beantemplate” class=”” abstract=””>
<property name=”name” value=”” />
</bean> //抽象bean
<bean id=”zibean” pareant=”beantemplate” /> //该bean是一个子bean
bean继承和java继承完全不同 前者是实例与实例之间的参数的延续,后者是一般到特殊的细化.前者bean父子类型可以不同,后者子类是一种特殊的父类
工厂bean 实现FactoryBean接口的bean 一般作为工具类bean
8.容器中bean的生命周期
管理bean生命周期的两个时机
注入依赖关系之后
销毁bean之前
9.基于xml schema的简化配置
9.1使用p命名空间配置属性
<beans xmlns:p=...
<bean id = class= p:age=”29” p:axe-ref=”stoneAxe” />
9.2使用util scheme 不作讨论
10.spring3.0提供的el表达式语言
<beans>
<!--使用util:properties 加载资源配置文件-->
< util:properties id=”confTest” location=”classpath:test_zh_CN.properties” />
<!--通过spEL配置name属性,在表达式里面调用对象
配置axe对象,通过el表达式创建对象-->
<bean id= “”class=”” p:name=”#{T(java.lang.Math() .random()}”//T的意思是告诉程序将括号里面的内容当作类来解析
p:axe=”#{new StoneAxe()}”>
<property name=””>
<!-- 在表达式中 访问其他bean对象的属性
<value>#{confTest.a}</value>
</propetry>
</bean>
</beans>
11.spring 的两种后处理器
bean后处理器
容器后处理器
11.1bean后处理器
bean后处理器是一种特殊的bean,不对外提供服务,他负责对容器中的bean进行后处理操作
比如为容器中的bean生成代理
bean后处理器会在目标bean实例创建成功后,对目标增强
bean后处理器必须实现 BeanPostProcessor接口,实现两个方法PostProcessorBeforeInitialization( Object bean ,string name)和PostProcessorAfterInitialization( bean, name)
会在目标bean初始化之前和之后进行增强
后处理器的用处是生成代理
11.2容器后处理器
对spring容器本身进行后处理
applicationContext.xml配置 属性占位符
<!-- 导入外部的properties文件 -->
<context:property-placeholder location="classpath:jdbc.properties"/>
12spring 的零配置支持
12.1采用注解的方式
标注bean的几个annotation :
@Component //标注普通 spring bean
@Controller //标注控制器组件类
@Service //标注一个业务逻辑组件类
@Repository //标注一个Dao组件类
需要在applicationContext.xml 配置如下
<!-- 自动扫描与装配bean -->
<context:component-scan base-package="cn.my.myClass">
<!--可选配置 扫描以Chinese结尾的类
<context:include-filter type=”regex” expression=”.*Chinese” />
</context:component-scan>
<exclude-filte>不扫描的类定义
@Scope(“prototype”) //指定bean的作用域
使用@Resource(name=””)配置依赖,如果省略里面的name则默认是set方法去掉set的首字母小写的组件
@DependsOn({“abx”,”cd”})
@Component
public class Chinese{}
表示在初始化Chinese之前,先初始化abx和cd两个bean
@Autowired //自动装配 按byType策略
13.资源访问
13.1 对各种类型的文件.二进制流等,通称为资源
java处理资源使用URL类和文件IO完成
spring提供了一个资源访问接口 Resource
这个接口有一下方法:
getInputStream()返回资源对应的输入流
exists() 判断resource指向的资源是否存在
getFile() 返回资源对应的File 对象
getURL() 返回资源对应的URL对象
Resource实现类 :
UrlResource //访问网络资源的实现类
ClassPathResource //访问类加载路径里的实现类
FileSystemResource //访问文件系统里资源的实现类
ServletContextResource //访问相对应ServletContext路径的资源
InputStreamResource //访问输入流资源的实现类
ByteArrayResource //访问字节数组资源的实现类
1.UrlResource
该类是URL类的包装类
file:用于访问文件系统
http:用于http协议访问资源
ftp:用于ftp协议的资源
一个使用URLResource访问本地磁盘资源
UrlResource ur=new UrlResource(“”file:book.xml);
System.out.println(“ur.getFileName”);
System.out.println(ur.getDescription());
SaxReader reader=new SaxReader();
Document doc=reader.read(ur.getFile());
//获取根元素
Element el=doc.getRootElement();
List l=el.elements();
for( Iterator it=l.iterator();it.hasNext();)
{
Element book=(Element) it.next();
List l1=book.elements();
for(Iterator it2=l1.iterator();it2.hasNext())
{
Element eee= (Element) it2.next();
System.out.println(eee.getTxet());
}
}
2.ServletContextResource
加载webContext路径下的资源
ServletContextResource src=new ServletContextResource(application,”WEB-IF/book.xml”);
3.ByteArarayResource
String file=””;
byte[] files=file.getBytes();
ByteArrayResource bar=newByteArrayResource(files);
13.2 ResourceLoader 和ResourceLoaderAware
后者接口持有前者接口的一个引用
ResourceLoader 有获得Resource实例的方法 getResource()
ApplicationContext 实现了ResourceLoader 接口
ApplicationContext ctx= new ClassPathXmlApplocation(“bean.xml”);
Resource re=ctx.getResource(“mypath/book.txt”);//该resource是ClassPathResource
如果appicationContext 是XmlWebApplicationContext ,那么resource是 ServletContextResource
当然可以强制指定使用什么类型的Resource类型
Resouce re=ctx.getResource(“classpath:book.xml”);
Resorce re=ctx.getResource(“http://localhost:8080/book.xml”);
强制访问系统资源
Resource re=ctx.getResource(“file:book.xml”);
13.3使用resource作为属性
bean访问资源可以采取两种方式,一种就是上面的通过代码获得Resource实例
一种是使用依赖注入
第二种方法耦合度低
public class ResourceTest{
private Resource re;
//提供set方法
在bean.xml中注入Resource
<bean id=”” class=” ResourceTest”>
<!--注入资源-->
<property name=”resource” value=”classpath:book.xml” />
</bean>
}
13.4 ApplicationContext 加载多个配置文件
(classpath*;bean.xml) 或者 (bean*.xml)
前者搜索classes路径下的所有bean.xml文件 或者搜索前缀为bean的所有xml文件
14.spring的AOP
面向切面编程和面向对象编程相互补充,面向对象编程将程序分解成各个层次的对象,面向切面编程将程序运行过程分为各个切面,前者是静态的,后者是动态方面
AspectJ 是基于java语言的AOP框架
14.1面向切面的编程的基本概念
AOP面向的是程序运行的各个步骤,希望以更好的方式组合业务处理的各个步骤
各步骤之间有较好的隔离线 源代码的无关性
术语:
切面(Aspect):业务流程运行的某个特定步骤,是切入点和通知的结合
连接点(joinpoint):所谓连接点是那些被拦截的点,在spring中连接点是哪些方法可以被拦截
切入点:被拦截到方法,是连接点的子集,连接点在增强以后变成了切入点
通知/增强(Advice):拦截以后要做的事情 ,有前置通知 后置通知 环绕通知 异常通知 最终通知
引介:在不改变代码的前提下,在运行期动态的添加一些方法和属性 是一种特殊的通知
目标对象(Target):被增强的对象
AOP代理:代理就是对目标对象的增强,spring代理可以是jdk代理(针对实现接口的目标对象)和cglib代理(目标对象没有实现接口)
织入:(weaving)对目标对象进行增强创建代理对象的过程
14.2面向切面编程的步骤
1)定义普通业务组件
2)定义切入点
3)定义增强处理
14.3 基于注解的面向切面编程
为了spring能够支持@AspectJ,需要配置xml
<beans xmlns:aop=...
>
<aop:aspectj-autoproxy /> //启动@AspectJ支持
1)定义切面bean
@Aspect
pubic class LogAspect{}
2)定义前置增强
@Aspect
public class BeforeAdviceTest
{
@Before(“execution(* cn.my.*.*(..))”) //@Before 定义了切入点,对my下的所有类的所有方法进行增强
public void authority()//增强处理的方法
{
system.out.println(“模拟执行权限检查”);
}
}
public class AfterReturningTest
{
@AfterReturning ( returning=”rvt” ,pointcut=”execution(* cn.my.*.*(..))”)后置增强 ,//允许在增强处理中使用rvt作为形参,该形参代表目标方法的返回值
public void log(Object rvt)
}
@AfterThrowing 异常通知
对目标方法的异常进行处理
@After 后置通知 不管目标方法如何,运行成功还是抛出异常,都会在之后执行增强的代码
@AfterReturning 只有在目标方法成功运行以后才会增强
@Around 环绕增强
@Around(”execution(* cn.my.*.*(..))”)
public Object processTX( ProceedingJoinPoint jp)
{
system.out.println(“执行方法之前”);
Object rvt=jp.proceed( new String[]{“被改变的参数”});//执行目标方法并保存返回的值
system.out.println(执行方法之后);
return rvt;
}
执行目标方法时,用到一个String[]数组 ,用来改变目标方法的参数
@pointcut //定义切入点
14.4基于xml的面向切面编程
1)配置切面
<aop:config>
<aop:aspect id=”” ref=”beforeAdviceBean” >
... <aop:after pointcut=”” method=”” />
</aop:aspect >
</aop:config>
<bean id= “beforeAdviceBean” class=”” />
2)配置增强处理
<aop:before ../>
<aop:after-returning />
<aop:after>
<aop: around>
<aop:pointcut id =”” expression=”” />//定义切入点
15spring的事务
事务分为全局事务和局部事务
全局事务由应用程序负责
局部事务 由Connection(jdbc)或者session(hibernate)负责
声明式事务管理:在xml配置
编码式事务管理
<!-- 配置SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation" value="classpath:hibernate.cfg.xml"></property>
<!-- 配置c3p0数据库连接池 -->
<property name="dataSource">
<!-- 配置声明式事务管理（采用注解的方式） -->
<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<tx:annotation-driven transaction-manager="txManager"/>
@Transactional
16.sprig 和strut2的整合
web.xml文件 配置
listener监听器用来创建spring 容器
此外如果spring有多个配置文件 要用contextConfigLocation配置
如果不指定spring的配置文件 那么会自动搜索applicationContext.xml
17.spring 和hibernate
sping提供了三个支持dao组件的工具类
HibernateDaoSupport
HibernateTemplate
HibernateCallback
也可以不用他们
17.1HibernateTemplate接口
delete()
save()
update()
get()
find()
...
17.2HibernateDaoSupport 类
两个方法
getHibernateTemplate() 获得HibernateTemplate实例,数据库操作由他完成
标签：
原文地址：http://www.cnblogs.com/chuanqimessi/p/4770010.html
