尚学堂Spring笔记
一、锲子
二、环境
三、环境搭建
四、关键技术
Ioc控制反转
AOP(面向切面编程)
spring对AOP的支持(采用Annotation的方式)
spring对AOP的支持(采用配置文件的方式)
spring对AOP的支持(关于接口) spring对AOP的支持(关于接口)二 Autowrire(自动装配)
根据名称自动装配
根据类型自动装配
Injection(依赖注入)
Proxy(代理)
静态代理
动态代理
spring Bean的作用域
五、整合
Spring + Hibernate
采用编程式事务
采用声明式事务
Spring + Struts
spring+struts的集成(第一种集成
方案
气瓶 现场处置方案 .pdf气瓶 现场处置方案 .doc见习基地管理方案.doc关于群访事件的化解方案建筑工地扬尘治理专项方案下载
) spring+struts的集成(第二种集成方案) Spring + Struts + Hibernate(SSH) 六、写在最后
一、锲子
在前一段时间内学习了一些Spring的知识，感觉还是需要整理一下自己的东
西，不然我感觉很是容易遗忘。
二、环境
本次学习用到了一些软硬件环境如下:
1. MyEclipse Enterprise Workbench 7.0 Milestone-1,MyEclipse 7.0 M1, 2. Spring 2.5
3. Struts 1.2
4. Hibernate 3.2
5. 其他(SVN等)
三、环境搭建
1、spring依赖库
* SPRING_HOME/dist/spring.jar
* SPRING_HOME/lib/jakarta-commons/commons-logging.jar
* SPRING_HOME/lib/log4j/log4j-1.2.14.jar 2、拷贝spring配置文件(applicationContext.xml)到src下 3、拷贝log4j配置文件(log4j.properties)到src下 提示:上面的一些jar包如果在现在的MyEclipse环境里可以通过添加对Spring的支持自动
添加，上面的一些配置文件都可以再Spring官方下载的Spring包中的例子程序中找到相应的
一些文件，修改后就可以使用
四、关键技术
Ioc控制反转
spring Ioc容器的关键点:
* 必须将被管理的对象定义到spring配置文件中
* 必须定义构造函数或setter方法，让spring将对象注入过来
方法的属性
后面通过读取配置文件，并新建工厂，通过工厂来获得bean
BeanFactory factory = new
ClassPathXmlApplicationContext("applicationContext.xml"); UserManager userManager = (UserManager)factory.getBean("XX");
AOP(面向切面编程)
spring对AOP的支持(采用Annotation的方式) 1、spring依赖库
* SPRING_HOME/dist/spring.jar
* SPRING_HOME/lib/jakarta-commons/commons-logging.jar
* SPRING_HOME/lib/log4j/log4j-1.2.14.jar
* SPRING_HOME/lib/aspectj/*.jar
2、采用Aspect定义切面
2、在Aspect定义Pointcut和Advice
4、启用AspectJ对Annotation的支持并且将Aspect类和目标对象配置到Ioc容器中
注意:在这种方法定义中，切入点的方法是不被执行的，它存在的目的仅仅是为了重用切入点 即Advice中通过方法名引用这个切人点
AOP一些关键技术:
* Cross cutting concern
* Aspect
* Advice
* Pointcut
* Joinpoint
* Weave
* Target Object
* Proxy
* Introduction
注意使用AOP的时候一定要添加相应的类库(jar包)
建一个Annotations的类，然后通过添加Spring对AOP的支持，也就是在Spring的配置文件中加入
就可以了
代码如下
package com.bjsxt.spring;
import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut;
/**
* 定义Aspect
* @author Administrator
*
*/
@Aspect
public class SecurityHandler {
/**
* 定义Pointcut,Pointcut的名称就是allAddMethod，此方法不能有返回值和参数，该方法只是一个
* 标识
*
* Pointcut的
内容
财务内部控制制度的内容财务内部控制制度的内容人员招聘与配置的内容项目成本控制的内容消防安全演练内容
是一个表达式，描述那些对象的那些方法(订阅Joinpoint)
*/
@Pointcut("execution(* add*(..)) || execution(* del*(..))")
private void allAddMethod(){};
/**
* 定义Advice，标识在那个切入点何处织入此方法
*/
@Before("allAddMethod()")
private void checkSecurity() {
System.out.println("----------checkSecurity()---------------");
}
}
客户端代码不变
spring对AOP的支持(采用配置文件的方式) 1、spring依赖库
* SPRING_HOME/dist/spring.jar
* SPRING_HOME/lib/jakarta-commons/commons-logging.jar
* SPRING_HOME/lib/log4j/log4j-1.2.14.jar
* SPRING_HOME/lib/aspectj/*.jar
2、配置如下
spring对AOP的支持(关于接口)
spring对AOP的支持
Aspect默认情况下不用实现接口，但对于目标对象(UserManagerImpl.java)，在默认情况
下必须实现接口
如果没有实现接口必须引入CGLIB库
我们可以通过Advice中添加一个JoinPoint参数，这个值会由spring自动传入，从JoinPoint中可以取得
参数值、方法名等等
代码
package com.bjsxt.spring;
import org.aspectj.lang.JoinPoint;
public class SecurityHandler {
private void checkSecurity(JoinPoint joinPoint) {
Object[] args = joinPoint.getArgs();
for (int i=0; i
JDK动态代理和CGLIB字节码生成的区别,
* JDK动态代理只能对实现了接口的类生成代理，而不能针对类
* CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法
因为是继承，所以该类或方法最好不要声明成final
Autowrire(自动装配)
根据名称自动装配
在Spring的配置文件头中加入default-autowire="byName" 其中bean里面的id一定与你的bean类名字一样，不然找不到并装配不了 根据类型自动装配
在Spring的配置文件头中加入default-autowire="byType"，Spring默认装配方式 其中bean里面的id可以与你的bean类名字不一样，可以通过class来查找你需要注入的属性
Injection(依赖注入)
spring的普通属性注入
什么是属性编辑器，作用,
* 自定义属性编辑器，spring配置文件中的字符串转换成相应的对象进行注入
spring已经有内置的属性编辑器，我们可以根据需求自己定义属性编辑器
* 如何定义属性编辑器,
* 继承PropertyEditorSupport类，覆写setAsText()方法
package com.bjsxt.spring;
import java.beans.PropertyEditorSupport;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* java.util.Date属性编辑器
* @author Administrator
*
*/
public class UtilDatePropertyEditor extends PropertyEditorSupport {
private String format="yyyy-MM-dd";
@Override
public void setAsText(String text) throws IllegalArgumentException
{
SimpleDateFormat sdf = new SimpleDateFormat(format);
try {
Date d = sdf.parse(text);
this.setValue(d);
} catch (ParseException e) {
e.printStackTrace();
}
}
public void setFormat(String format) {
this.format = format;
}
}
* 将属性编辑器注册到spring中
依赖对象的注入方式，可以采用:
* ref属性
*
[标签
* 内部来定义
如何将公共的注入定义描述出来,
* 通过标签定义公共的属性，指定abstract=true
* 具有相同属性的类在标签中指定其parent属性
Proxy(代理)
静态代理
静态代理只需写一个静态代理类就可以了
package com.bjsxt.spring;
public class UserManagerImplProxy implements UserManager {
private UserManager userManager;
public UserManagerImplProxy(UserManager userManager) {
this.userManager = userManager;
}
public void addUser(String username, String password) {
checkSecurity();
this.userManager.addUser(username, password);
}
public void deleteUser(int id) {
checkSecurity();
this.userManager.deleteUser(id);
}
public String findUserById(int id) {
return null;
}
public void modifyUser(int id, String username, String password) {
}
private void checkSecurity() {
System.out.println("----------checkSecurity()---------------"); }
}
客户端代码
UserManager userManager = new UserManagerImplProxy(new
UserManagerImpl());
userManager.addUser("张三", "123");
动态代理
动态代理的话就要写一个Handler，通过Handler来生成管理类的代理
package com.bjsxt.spring;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class SecurityHandler implements InvocationHandler {
private Object targetObject;
public Object newProxy(Object targetObject) {
this.targetObject = targetObject;
return
Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClas
s().getInterfaces(),
this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
checkSecurity();
Object ret = null;
try {
ret = method.invoke(this.targetObject, args);
}catch(Exception e) {
e.printStackTrace();
throw new java.lang.RuntimeException(e);
}
return ret;
}
private void checkSecurity() {
System.out.println("----------checkSecurity()---------------");
}
}
客户端代码
SecurityHandler handler = new SecurityHandler();
UserManager userManager = (UserManager)handler.newProxy(new
UserManagerImpl());
userManager.addUser("张三", "123"); spring Bean的作用域
scope可以取值:
* singleton:每次调用getBean的时候返回相同的实例
* prototype:每次调用getBean的时候返回不同的实例 或者
五、整合
Spring + Hibernate 采用编程式事务
1、getCurrentSession()与openSession()的区别,
* 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession()
创建的session则不会
* 采用getCurrentSession()创建的session在commit或rollback时会自动关闭，而采用openSession()
创建的session必须手动关闭
2、使用getCurrentSession()需要在hibernate.cfg.xml文件中加入如下配置:
* 如果使用的是本地事务(jdbc事务)
thread
* 如果使用的是全局事务(jta事务)
jta
如
采用声明式事务
1、声明式事务配置
* 配置SessionFactory
* 配置事务管理器
* 事务的传播特性
* 那些类那些方法使用事务
2、编写业务逻辑方法
* 继承HibernateDaoSupport类，使用HibernateTemplate来持久化，HibernateTemplate是
Hibernate Session的轻量级封装
* 默认情况下运行期异常才会回滚(包括继承了RuntimeException子类)，普通异常是不会回滚的
* 编写业务逻辑方法时，最好将异常一直向上抛出，在表示层(struts)处理
* 关于事务边界的设置，通常设置到业务层(Manager)，不要添加到Dao上
3、了解事务的几种传播特性
1. PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启
2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行
3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。
6. PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常
7. PROPAGATION_NESTED:如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务,
则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行
4、Spring事务的隔离级别
1. ISOLATION_DEFAULT: 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.
另外四个与JDBC的隔离级别相对应
2. ISOLATION_READ_UNCOMMITTED: 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。
这种隔离级别会产生脏读，不可重复读和幻像读。
3. ISOLATION_READ_COMMITTED: 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据
4. ISOLATION_REPEATABLE_READ: 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。
它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。
5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。
除了防止脏读，不可重复读外，还避免了幻像读。
配置声明式事务
classpath:hibernate.cfg.xml
]
浙公网安备 33021202002483