Spring-部分知识点概述（持续更新）

Spring学习记录：

IOC控制反转

（一）

开发流程：

（1）新建项目

（2）导入jar包：spring.jar commons-loging.jar

（3）编写配置文件

配置文件头模板：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> 
<bean id="..." class="...">

<!-- collaborators and configuration for this bean go here -->

</bean>

<bean id="..." class="...">

<!-- collaborators and configuration for this bean go here -->

</bean>

<!-- more bean definitions go here -->

</beans>

（4）实例化spring容器

a 在类路径下寻找配置文件来实例化容器

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

b 在文件系统路径下寻找配置文件实力化

ApplicationContext ctx = new String[]{“d:\\beans.xml“});

FileSystemXmlApplicationContext(new

Spring的配置文件可以指定多个，可以通过String数组传入。

（5）新建单元测试

（6）建立实现类

（7）建立接口类

（8）完善配置文件，将bean交给spring容器管理

简单实例练习：

详见：点击打开链接

（1）接口

PersonService.java:

package com.sw.servc;

public interface PersonService {

void save();

}

（2）新建bean

PersonServiceBean.java:

package com.sw.service.impl;

import com.sw.servc.PersonService;

public class PersonServiceBean implements PersonService {

/* (non-Javadoc)

* @see com.sw.service.impl.PersonService#save()

*/

@Override

public void save(){

System.out.println("save()");

}

}

（3）新建beans.xml配置文件

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> 
<!-- id值第一个字母使用小写 -->

<bean id="personService" class="com.sw.service.impl.PersonServiceBean"></bean>

</beans>

（4）新建测试单元进行测试

package com.sw.junit.test;

import org.junit.BeforeClass;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.sw.servc.PersonService;

public class SpringTest {

@BeforeClass

public static void setUpBeforeClass() throws Exception {

}

@Test

public void instanceSpring () {

//实例化容器

ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");

//获取bean

PersonService personService=(PersonService) ctx.getBean("personService");//接口引用

//调用业务方法

personService.save();

}

}

（二）

三种实例化Bean的方式

1.使用类构造器实例化

<bean id=“orderService" class="com.sw.OrderServiceBean"/>

2.使用静态工厂方法实例化

<bean id="personService" class="com.sw.service.OrderFactory" factory-method="createOrder"/>

public class OrderFactory {

public static OrderServiceBean createOrder(){

return new OrderServiceBean();

}

}

3.使用实例工厂方法实例化:

<bean id="personServiceFactory" class="com.sw.service.OrderFactory"/>

<bean id="personService" factory-bean="personServiceFactory" factory-method="createOrder"/>

public class OrderFactory {

public OrderServiceBean createOrder(){

return new OrderServiceBean();

}

}

Bean的作用域scope

.singleton

 在每个Spring IoC容器中一个bean定义只有一个对象实例。默认情况下会在

 容器启动时初始化bean，但我们可以指定Bean节点的lazy-init=“true”来延迟

 初始化bean，这时候，只有第一次获取bean才初始化bean。如：

 <bean id="xxx" class="com.sw.OrderServiceBean" lazy-init="true"/>

如果想对所有bean都应用延迟初始化，可以在根节点beans设置default-lazy-init=“true“，如下：

<beans default-lazy-init=“true“ ...>  作用域为protoype时 也是延迟初始化

.prototype

 每次从容器获取bean都是新的对象。

 

.request

.session

.global session

指定Bean的初始化方法和销毁方法

<bean id="xxx" class="com.sw.OrderServiceBean" init-method="init" destroy-method="close"/>

（三）

注入依赖对象（注入其他bean）：

使用构造器注入

使用属性setter方法注入

基本类型对象注入：

构造器注入：点击打开链接

详见：点击打开链接（set注入）

<bean id="orderService" class="com.sw.service.OrderServiceBean">

<constructor-arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入

<property name=“name” value=“zhao/>//属性setter方法注入

</bean>

注入其他bean：

方式一

<bean id="orderDao" class="com.sw.service.OrderDaoBean"/>

<bean id="orderService" class="com.sw.service.OrderServiceBean">

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

</bean>

方式二(使用内部bean,但该bean不能被其他bean使用)

<bean id="orderService" class="com.sw.service.OrderServiceBean">

<property name="orderDao">

<bean class="com.sw.service.OrderDaoBean"/>

</property>

</bean>

集合类型的装配：

详见：点击打开链接

public class OrderServiceBean {

private Set<String> sets = new HashSet<String>();

private List<String> lists = new ArrayList<String>();

private Properties properties = new Properties();

private Map<String, String> maps = new HashMap<String, String>();

....//这里省略属性的getter和setter方法

}

xml文件：

<bean id="order" class="com.sw.service.OrderServiceBean">

<property name="lists">

<list>

<value>xc</value>

</list>

</property>

<property name="sets">

<set>

<value>set</value>

</set>

</property>

<property name="maps">

<map>

<entry key="xc" value="28"/>

</map>

</property>

<property name="properties">

<props>

<prop key="12">sss</prop>

</props>

</property>

</bean>

注入依赖对象可以采用手工装配或自动装配，在实际应用中建议使用手工装配，因为自动装配会产生未知情况,开发人员无法预见最终的装配结果。

1.手工装配依赖对象

2.自动装配依赖对象

手工装配依赖对象，在这种方式中又有两种编程方式

1. 在xml配置文件中，通过在bean节点下配置，如

<bean id="orderService" class="com.sw.service.OrderServiceBean">

<constructor-arg index=“0” type=“java.lang.String” value=“xxx”/>//构造器注入

<property name=“name” value=“zhao/>//属性setter方法注入

</bean>

2. 在java代码中使用@Autowired或@Resource注解方式进行装配。但我们需要在xml配置文件中配置以下信息：

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-2.5.xsd"> 
<context:annotation-config/>

</beans>

这个配置隐式注册了多个对注释进行解析处理的处理器:AutowiredAnnotationBeanPostProcessor，CommonAnnotationBeanPostProcessor，PersistenceAnnotationBeanPostProcessor，RequiredAnnotationBeanPostProcessor

      注： @Resource注解在spring安装目录的lib\j2ee\common-annotations.jar

     

      详见：点击打开链接

      在java代码中使用@Autowired或@Resource注解方式进行装配，这两个注解的区别是：@Autowired 默认按类型装配，@Resource默认按名称装配，当找不到与名称匹配的bean才会按类型装配。

    @Autowired

    private PersonDao  personDao;//用于字段上

    @Autowired

    public void setOrderDao(OrderDao orderDao) {//用于属性的setter方法上

        this.orderDao = orderDao;

    }

@Autowired注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false。如果我们想使用按名称装配，可以结合@Qualifier注解一起使用。如下：

    @Autowired  @Qualifier("personDaoBean")

    private PersonDao  personDao;

@Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上，但它默认按名称装配。名称可以通过@Resource的name属性指定，如果没有指定name属性，当注解标注在字段上，即默认取字段的名称作为bean名称寻找依赖对象，当注解标注在属性的setter方法上，即默认取属性名作为bean名称寻找依赖对象。

    @Resource(name=“personDaoBean”)

    private PersonDao  personDao;//用于字段上

注意：如果没有指定name属性，并且按照默认的名称仍然找不到依赖对象时， @Resource注解会回退到按类型装配。但一旦指定了name属性，就只能按名称装配了。

自动装配：

对于自动装配，大家了解一下就可以了，实在不推荐大家使用。例子：

<bean id="..." class="..." autowire="byType"/>

autowire属性取值如下：

byType：按类型装配，可以根据属性的类型，在容器中寻找跟该类型匹配的bean。如果发现多个，那么将会抛出异常。如果没有找到，即属性值为null。

byName：按名称装配，可以根据属性的名称，在容器中寻找跟该属性名相同的bean，如果没有找到，即属性值为null。

constructor与byType的方式类似，不同之处在于它应用于构造器参数。如果在容器中没有找到与构造器参数类型一致的bean，那么将会抛出异常。

autodetect：通过bean类的自省机制（introspection）来决定是使用constructor还是byType方式进行自动装配。如果发现默认的构造器，那么将使用byType方式。

（四）

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

详见：点击打开链接

前面的例子我们都是使用XML的bean定义来配置组件。在一个稍大的项目中，通常会有上百个组件，如果这些这组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找及维护起来也不太方便。spring2.5为我们引入了组件自动扫描机制，他可以在类路径底下寻找标注了@Component、@Service、@Controller、@Repository注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件是一样的。要使用自动扫描机制，我们需要打开以下配置信息:

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:context="http://www.springframework.org/schema/context"

xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/context  http://www.springframework.org/schema/context/spring-context-2.5.xsd"> 
<context:component-scan base-package="com.sw"/>

</beans>

<context:component-scan base-package=“com.sw”/>默认开启了<context:annotation-config/>     其中base-package为需要扫描的包(含子包)。

@Service用于标注业务层组件、 @Controller用于标注控制层组件（如struts中的action）、@Repository用于标注数据访问组件，即DAO组件。而@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

（五）

AOP

代理方式：

详见：点击打开链接

1、JDK动态代理：

public class JDKProxy implements InvocationHandler {

private Object targetObject;//代理的目标对象

public Object createProxyInstance(Object targetObject){

this.targetObject = targetObject;

/*

* 第一个参数设置代码使用的类装载器,一般采用跟目标类相同的类装载器

* 第二个参数设置代理类实现的接口

* 第三个参数设置回调对象,当代理对象的方法被调用时,会委派给该参数指定对象的invoke方法

*/

return Proxy.newProxyInstance(this.targetObject.getClass().getClassLoader(),

this.targetObject.getClass().getInterfaces(), this);

}

public Object invoke(Object proxy, Method method, Object[] args)

throws Throwable {

return method.invoke(this.targetObject, args);//把方法调用委派给目标对象

}

}

当目标类实现了接口，我们可以使用jdk的Proxy来生成代理对象。

/2使用CGLIB生成代理：

public class CGLIBProxy implements MethodInterceptor {

private Object targetObject;//代理的目标对象

public Object createProxyInstance(Object targetObject){

this.targetObject = targetObject;

Enhancer enhancer = new Enhancer();//该类用于生成代理对象

enhancer.setSuperclass(this.targetObject.getClass());//设置父类

enhancer.setCallback(this);//设置回调用对象为本身

return enhancer.create();

}

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

MethodProxy methodProxy) throws Throwable {

return methodProxy.invoke(this.targetObject, args);

}

}

CGLIB可以生成目标类的子类，并重写父类非final修饰符的方法。

使用jdk的Proxy来生成代理对象。

Aspect(切面):指横切性关注点的抽象即为切面,它与类相似,只是两者的关注点不一样,类是对物体特征的抽象,而切面横切性关注点的抽象.

joinpoint(连接点):所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点,实际上joinpoint还可以是field或类构造器)

Pointcut(切入点):所谓切入点是指我们要对那些joinpoint进行拦截的定义.

Advice(通知):所谓通知是指拦截到joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知

Target(目标对象):代理的目标对象

Weave(织入):指将aspects应用到target对象并导致proxy对象创建的过程称为织入.

Introduction(引入):在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

2、

使用Spring面向切面（AOP）编程

要进行AOP编程，首先我们要在spring的配置文件中引入aop命名空间：

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

</beans>

Spring提供了两种切面声明方式，实际工作中我们可以选用其中一种：

基于XML配置方式声明切面。详见：点击打开链接

基于注解方式声明切面。详见：点击打开链接

（1）基于注解方式声明切面：

首先启动对@AspectJ注解的支持(蓝色部分)：

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<aop:aspectj-autoproxy/>

<bean id="orderservice" class="com.sw.service.OrderServiceBean"/>

<bean id="log" class="com.sw.service.LogPrint"/>

</beans>

@Aspect

public class LogPrint {

@Pointcut("execution(* com.sw.service..*.*(..))")

private void anyMethod() {}//声明一个切入点

@Before("anyMethod() && args(userName)")//定义前置通知

public void doAccessCheck(String userName) {

}

@AfterReturning(pointcut="anyMethod()",returning="revalue")//定义后置通知

public void doReturnCheck(String revalue) {

}

@AfterThrowing(pointcut="anyMethod()", throwing="ex")//定义例外通知

public void doExceptionAction(Exception ex) {

}

@After("anyMethod()")//定义最终通知

public void doReleaseAction() {

}

@Around("anyMethod()")//环绕通知

public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {

return pjp.proceed();

}

}

（2）使用xml方式进行切面编程

java文件

public class LogPrint {

public void doAccessCheck() {}定义前置通知

public void doReturnCheck() {}定义后置通知

public void doExceptionAction() {}定义例外通知

public void doReleaseAction() {}定义最终通知

public Object doBasicProfiling(ProceedingJoinPoint pjp) throws Throwable {

return pjp.proceed();环绕通知

}

xml文件引用:

<bean id="orderservice" class="com.sw.service.OrderServiceBean"/>

<bean id="log" class="com.sw.service.LogPrint"/>

<aop:config>

<aop:aspect id="myaop" ref="log">

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

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

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

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

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

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

</aop:aspect>

</aop:config>

（六）

Spring+JDBC集成开发 详见：点击打开链接

步骤：

1、配置数据源,如:

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>

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

<property name="username" value="root"/>

<property name="password" value="123456"/>

.....略

</bean>

2、配置事务。配置事务时，需要在xml配置文件中引入用于声明事务的tx命名空间,

事务的配置方式有两种：注解方式和基于XML配置方式。

xml文件中引入命名空间：

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:tx="http://www.springframework.org/schema/tx"

xsi:schemaLocation="http://www.springframework.org/schema/beans
 http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

</beans>

配置数据源：

<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">

<property name="driverClassName" value="org.gjt.mm.mysql.Driver"/>

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

<property name="username" value="root"/>

<property name="password" value="123456"/>

<!-- 连接池启动时的初始值 -->

<property name="initialSize" value="1"/>

<!-- 连接池的最大值 -->

<property name="maxActive" value="500"/>

<!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->

<property name="maxIdle" value="2"/>

<!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->

<property name="minIdle" value="1"/>

</bean>

使用<context:property-placeholder location=“jdbc.properties”/>属性占位符

使用注解配置事务：

 

<!-- 采用注解方式配置事务 -->

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

</bean>

<!-- 采用@Transactional注解方式使用事务 -->

<tx:annotation-driven transaction-manager="txManager"/>

xml配置事务：

<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

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

</bean>

<aop:config>

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

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

</aop:config>

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

<tx:attributes>

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

<tx:method name="*"/>

</tx:attributes>

</tx:advice>

使用JdbcTemplate进行insert/update/delete操作：

@Service @Transactional

public class PersonServiceBean implements PersonService {

private JdbcTemplate jdbcTemplate;

@Resource

public void setDataSource(DataSource dataSource) {

this.jdbcTemplate = new JdbcTemplate(dataSource);

}

//添加

public void save(Person person) throws Exception{

jdbcTemplate.update("insert into person (name) values(?)",

new Object[]{person.getName()}, new int[]{java.sql.Types.VARCHAR});

}

}

使用JdbcTemplate获取一条记录：

@Service @Transactional

public class PersonServiceBean implements PersonService {

private JdbcTemplate jdbcTemplate;

@Resource

public void setDataSource(DataSource dataSource) {

this.jdbcTemplate = new JdbcTemplate(dataSource);

}

public Person getPerson(Integer id){

RowMapper rowMapper = new RowMapper(){

public Object mapRow(ResultSet rs, int rowNum) throws SQLException {

Person person = new Person();

person.setId(rs.getInt("id"));

person.setName(rs.getString("name"));

return person;

}

};

return (Person)jdbcTemplate.queryForObject("select * from person where id=?",

new Object[]{id}, new int[]{java.sql.Types.INTEGER}, rowMapper);

}

}

使用JdbcTemplate获取多条记录：

@Service @Transactional

public class PersonServiceBean implements PersonService {

private JdbcTemplate jdbcTemplate;

@Resource

public void setDataSource(DataSource dataSource) {

this.jdbcTemplate = new JdbcTemplate(dataSource);

}

public List<Person> getPersons(){

RowMapper rowMapper = new RowMapper(){

public Object mapRow(ResultSet rs, int rowNum) throws SQLException {

Person person = new Person();

person.setId(rs.getInt("id"));

person.setName(rs.getString("name"));

return person;

}

};

return jdbcTemplate.query("select * from person", rowMapper);

}

}

事务传播属性：

REQUIRED：业务方法需要在一个事务中运行。如果方法运行时，

已经处在一个事务中，那么加入到该事务，否则为自己创建一个新的事务。

NOT_SUPPORTED：声明方法不需要事务。如果方法没有关联到一个事务，

容器不会为它开启事务。如果方法在一个事务中被调用，该事务会被挂起，

在方法调用结束后，原先的事务便会恢复执行。

REQUIRESNEW：属性表明不管是否存在事务，业务方法总会为自己发起一个新

的事务。如果方法已经运行在一个事务中，则原有事务会被挂起，

新的事务会被创建，直到方法执行结束，新事务才算结束，

原先的事务才会恢复执行。

MANDATORY：该属性指定业务方法只能在一个已经存在的事务中执行，

业务方法不能发起自己的事务。如果业务方法在没有事务的环境下调用，

容器就会抛出例外。

SUPPORTS：这一事务属性表明，如果业务方法在某个事务范围内被调用，

则方法成为该事务的一部分。如果业务方法在事务范围外被调用，

则方法在没有事务的环境下执行。

Never：指定业务方法绝对不能在事务范围内执行。如果业务方法在某个

事务中执行，容器会抛出例外，只有业务方法没有关联到任何事务，

才能正常执行。

NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中.

如果没有活动事务, 则按REQUIRED属性执行.它使用了一个单独的事务，

这个事务拥有多个可以回滚的保存点。内部事务的回滚不会对外部事

务造成影响。它只对DataSourceTransactionManager事务管理器起效

数据库系统提供的四种事务隔离级：

数据库系统提供了四种事务隔离级别供用户选择。

不同的隔离级别采用不同的锁类型来实现，在四种隔离级别中，

Serializable的隔离级别最高，Read Uncommited的隔离级别最低。

大多数据库默认的隔离级别为Read Commited，如SqlServer，当然也有

少部分数据库默认的隔离级别为Repeatable Read ，如Mysql

Read Uncommited：读未提交数据(会出现脏读,不可重复读和幻读)。

Read Commited：读已提交数据(会出现不可重复读和幻读)

Repeatable Read：可重复读(会出现幻读)

Serializable：串行化

脏读：一个事务读取到另一事务未提交的更新新据。

不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。

换句话说就是，后续读取可以读到另一事务已提交的更新数据。

相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，

也就是，后续读取不能读到另一事务已提交的更新数据。

幻读：一个事务读取到另一事务已提交的insert数据。

 

 

（七）

Spring+Hibernate+Struts1.3

SSH

SSJ