MVC
是一种软件设计的典范，用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在修改界面和用户交互的同时，不用重新编写业务逻辑。
Model(模型层)
View（视图层）
Controller（控制层）
Hibernate
1.Hibernate核心组件
配置文件 映射文件 持久化类
Configuration类
SessionFactory接口
Session接口
Query接口
Transcation接口
2.Hibernate运行过程
A.Hibernate首先调用Configuration类读取配置文件和映射文件，并利用这些信息生成一个sessiongFactory对象
Configuration config = new Configuration().configure("/hibernate/hibernate.cfg.xml");
sessionFactory = config.buildSessionFactory();B.sessionFactory对象打开一个session对象，并用session对象生成Transcation对象，然后通过session的save()、update()、saveOrUpdate()、delete()、close()、clean()、evict()、get()、load()等方法对对象进行操作，通过session生成Query对象（Session.createQuery()），进行查询操作
Students stu = new Students();
Session session = sessionFactory.openSession();//生成Session实例
Transaction tx = session.beginTransaction();
session.save(stu);//保存持久类对象
tx.commit();//提交到数据库
session.close();Hibernate配置文件和映射文件
配置文件：
<hibernate-configuration>
<session-factory>
<property name="connection.url">jdbc:mysql://localhost:3306/study</property>
<property name="connection.username">root</property>
<property name="connection.password">root</property>
<property name="connection.driver_class">org.gjt.mm.mysql.Driver</property>
<property name="dialect">org.hibernate.dialect.MySQLDialect</
<property name="show_sql">true</property>
<mapping resource="hibernate/PO/TRegister.hbm.xml" />
</session-factory>
</hibernate-configuration>
映射文件：
<hibernate-mapping>
<class name="hibernate.PO.TRegister" table="t_register">
<id name="id" type="java.lang.Integer">
<column name="id" />
<!-- 我在MYSQL中并没有设置该字段递增，但在Hibernate中依然可以设置为递增 -->
<generator class="increment" />
</id>
<property name="userName" type="java.lang.String"><column name="userName" length="30" /></property>
<property name="userPwd" type="java.lang.String"><column name="userPwd" length="30" /></property>
<property name="sex" type="java.lang.String"><column name="sex" length="10" /></property>
<property name="age" type="java.lang.Integer"><column name="age" /></property>
</class>
</hibernate-mapping>3.Hibernate持久化对象的三种状态
瞬时状态：（a）一个对象被new出来的时候进入瞬时状态，不与数据库中的数据相关联；（b）通过sava()和saveOrUpdate()转化为持久
化状态；（c）如果没有被对象引用则被GC回收。
持久化状态：（a）持久化对象在数据库中有相应的记录，拥有一个唯一的标识符；（b）持久化对象通过session的delete()方法转化为瞬
时状态（在数据库中对应的数据被删除，该对象不再与数据库的记录关联），通过session的close()、clean()、evict()方法转化
为游离状态；（c）持久化对象被修改后不会马上同步到数据库，直到数据库事务提交;
游离状态：（a）与某持久化对象关联的session被关闭，游离状态拥有数据库的识别值，但已不在持久化管理范围之内；（b）可以通过
session的save（）和saveOrUpdate（）转化为持久化状态；（c）如果不被引用则被GC回收。
Hibernate对象的三种状态实例详解Hibernate对象的三种状态详解
4.Hibernate操作类与类直接的关系
5.Hibernate的缓存机制
（1）Hibernate缓存的作用
Hibernate是一个持久化的框架，经常要访问物理数据库，为了降低应用程序访问物理数据库的频次，从而提高程序的运行效率。缓存内的数据是物理数据源中的数据进行复制，应用程序在运行的时候从缓存中读写数据，在特定的时刻或事件会同步数据源和缓存的数据。
（2）Hibernate的分类
一级缓存：就是session缓存，由于一个session的生命周期通常对应于一个数据库事务或应用事务，所以一级缓存是事务级的缓存，一级缓
存是内置的也是必须的，不可被卸载；
二级缓存：就是SessionFactory的缓存，由于SessionFactory的生命周期对应一个程序整个过程，所以二级缓存是进程范围的缓存，有可能
出现并发问题，所以应当采取适当的并发访问策略，二级缓存是可选的。
（3）Hibernate查找对象如何应用缓存？
首先根据ID在session一级缓存里查，查不到，如果配置了二级缓存，就从二级SessionFactory缓存中查，还查不到再查数据库，把结果按照ID放入缓存，增删改的时候同时更新缓存。
（4）Hibernate管理缓存实例
无论何时，我们在管理Hibernate缓存（Managing the caches）时，当你给save()、update()或saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。
当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。
Hibernate缓存详解
5.Hibernate的其他小问题
（1）Hibernate的load（）和get（）（都是通过对象ID获取对象）
①load是懒加载，当调用session.load(User.class,2)时，只是取得了一个代理对象，这个代理对象只是保存了对象的ID值，并不发
送SQL语句，到数据库中去查询对象。只有当调用该对象的其他属性的时候，才会发送SQL语句，到数据库中去查询我们的对象。
②get不同，当调用session.get(User.class,2)是，直接发送SQL语句到数据库中查询该对象。
③当数据库中没有该ID对应的记录时，load报ObjectNotFoundException异常，而get报NullPointException的异常
Hibernate的load和get的区别详解
（2）Hibernate的好处
①对JDBC操作数据库的代码进行了封装，简化了代码
②轻量级框架，性能高
③支持多种关系型数据库，映射灵活支持从一对一到一对多的多种复制关系。
④是对ORM一个很好的实现，能够像操作对象一样操作数据，不用对SQL进行直接编码。
（3）Hibernate查询方式
load（User.class,id）和get（），对象导航查询(stu.getName())， hql（面向对象的查询） ，sql
（4）Hibernate实现分页
Query query = session.createQuery(“from User”);
query.setFirstResult(0);//从第一条记录开始
query.setMaxResults(4);//取出四条记录
List userList = query.list();
Hibernate分页详解
Struts2
1.struts2的作用
类似于servlet，接受请求调用DAO，返回视图
优势：请求和返回视图的映射关系都配置在Struts.xml
2.Struts2的工作流程
（1）客户端浏览器发送HTTP请求
（2）根据web.xml配置，该请求被FilterDispatch （现在更新为StrutsPrepareAndExecyeFilter）接受
（3）根据Struts.xml配置，找到需要调用的Action类和方法，并通过IOC的方式把值注入给Action
（4）Action调用业务逻辑组件处理业务逻辑（包含表单验证）
（5）Action执行完毕，根据Struts.xml配置找到对应的返回结果result，并跳转到相应的页面
（6）返回HTTP响应到客户端浏览器
3.struts2工作原理
（1）.用户通过HttpServletRequest获取用户请求
ActionContextCleanUp ：是一个可选的过滤器，主要用于与其他的框架进行集成（例如 SiteMesh）
FilterDispatch（2.0~2.1.2版本的核心控制器），最新过滤器：StrutsPrepareAndExecuteFilter
替代原因：加入我们想写一个过滤器，FilterDispatch一般在Struts2的顶端写一个Filter，而StrutsPrepareAndExcuteFilter可以在执行
action之前添加自己的Filter。
（2）.用户请求经过一系列的过滤器，只有.action后缀的请求才能到达ActionMapper，查找请求有没有一个指定的action
（3）.如果有则通过StrutsPrepareAndExecuteFilter,找到ActionProxy，ActionProxy通过Configuration Manager读取Struts.xml，找到具体
的Action类，然后通过ActionProxy来创建反向的实例；
（4）.再次经过一系列的拦截器，执行到action返回result（也是一个字符串对象），该Result对应一系列的视图：jsp
（5）.然后在经过一系列的拦截器，通过HttpServletResponse返回到我们的用户的实例。
4.Struts2的核心文件
（1）web.xml：通常的MVC框架都需要Web应用加载一个核心控制器，对于Struts2框架而言，需要加载StrutsPrepareAndExecuteFilter
来加载Struts2
（2）Struts.xml：Struts2的核心配置文件，该文件主要是管理应用中的Action映射，以及该Action包含的Result定义。
包含的内容：①全局属性；②用户请求和响应Action之间的关系；③Action可能用到的参数和返回结果；④各种拦截器
的配置
（3）Struts.properties：Struts2的全局属性文件，自动加载，该文件包含很多Key-value，这个文件完全可以不要，我们可以使用constant元素，配置在struts.xml文件中
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
<struts>
<include file="struts-resource.xml"/>//include可以包含其他的xml文件，某个模块都可以写一个struts.xml文件
<include file="struts-action.xml"/>
<include file="struts-aware.xml"/>
<include file="struts-ognl.xml"/>
<!--设置模式为开发模式 constant标签用于配置属性
<constant name="struts.devMode" value="true" />
-->
<!--name:包名; extends:继承父类的包名，默认是struts-default; namespace:包的命名空间,如果是/test则访问的地址是http://localhost:8080/struts2/test/xx.action ,如果是/ 则直接访问http://localhost:8080/struts2/xx.action
-->
<package name="first" extends="struts-default" namespace="/test" >//配置文件中那个要有多个包，但包的名称要唯一,可以在某些包上加一下扩展。
<!-- 定义默认的拦截器，每个action都会自动引用默认，如果Action中引用了其他拦截器，默认拦截器无效 -->
<default-action-ref name="exception"/>
<action name="exception">
<result type="redirect">/error/exception.jsp</result>
</action>
<!-- 全局结果集，包里的action都可以引用-->
<global-results>
<result name="input">/error.jsp</result>
</global-results>
<!-- name:名字 class:对应的类路径；method:调用action中的方法名-->
<action name="login" class="com.mkk.action.LoginAction" method="">
<!-- 节点配置
name:result名称和Action中返回值相同
type:result的类型
-->
<result name="success" type="redirect">/success.jsp</result>
<result name="error">/fail.jsp</result>
<!-- 引用拦截器配置(name:拦截器的名称或拦截器栈的名称) -->
<interceptor-ref name="timer"/>
<interceptor-ref name="defaultStack"/>
</action>
<!-- forward action 转发跳转 -->
<action name="result">
<result type="redirect">/result/result.jsp</result>
</action>
</package>
</struts>5.Action
Action的三种创建方式
struts.xml中action对应的class,有以下三种
普通java文件,里面有execute()方法
实现Action接口
继承自ActionSupport类(这当然是推荐的啦,因为父类中实现了很多有用的方法)
Action的动态调用方法
通过配置文件中action的method属性指定
这个涉及到action的通配符: 星号(*)表示所有, {数字} 表示第几个通配符
/note_{1}.jsp
使用通配符,理解约定优于配置的思想
Action的三种传递并接受参数的方法:
1.使用Action的属性接收参数：
a.定义：在Action类中定义属性，创建get和set方法；
b.接收：通过属性接收参数，如：userName；
c.发送：使用属性名传递参数，如：user1!add?userName=Magci；
struts2 Action获取表单传值
1.通过属性驱动式
**JSP:**
<form action="sys/login.action" method="post">
<input type="text" name="username">
<input type="submit" value="submit">
</form>
**Action:直接通过get、set方法获取。**
public class sysAction extends ActionSupport{
private String username;
public String login() throws Exception {
System.out.println(username);
return SUCCESS;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username= username;
}
}2.使用DomainModel接收参数：
a.定义：定义Model类，在Action中定义Model类的对象（不需要new），创建该对象的get和set方法；
b.接收：通过对象的属性接收参数，如：user.getUserName()；
c.发送：使用对象的属性传递参数，如：user2!add?user.userName=MGC；
**JSP:**
<form action="sys/login.action" method="post">
<input type="text" name="user.username">
<input type="text" name="teacher.level">
<input type="submit" value="submit">
</form>
**Action: 必须提供set方法**
public class sysAction extends ActionSupport{
private User user;
private Teacher teacher;
public String login() throws Exception {
System.out.println(user.getUsername());
System.out.println(teacher.getLevel());
return SUCCESS;
}
public void setUser(User user) {
this.user = user;
}
public void setTeacher(Teacher teacher) {
this.teacher = teacher;
}
}3.使用ModelDriven接收参数：
a.定义：Action实现ModelDriven泛型接口，定义Model类的对象（必须new），通过getModel方法返回该对象；
b.接收：通过对象的属性接收参数，如：user.getUserName()；
c.发送：直接使用属性名传递参数，如：user2!add?userName=MGC
模型驱动方式，必须要实现ModelDriven接口。对于要传入多个model第二种方式不方便
JSP:
<form action="sys/login.action" method="post">
<input type="text" name="username">
<input type="submit" value="submit">
</form>
Action:必须实现getModel() 方法
复制代码
public class sysAction extends ActionSupport implements ModelDriven<User>{
private User user;
public String login() throws Exception {
System.out.println(getModel().getUsername());
return SUCCESS;
}
public User getModel() {
if (null == user) {
return user = new User();
}
return user;
}
}6.Struts2标签和OGNL表达式详解：
（1）Struts2标签
在要使用标签的jsp页面引入标签库：
<%@ taglib uri=”/struts-tags” prefix=”s”%>
①property标签
②iterator标签的使用
③if else语句的使用
④URL标签
⑤data标签
⑥表单
（2）OGNL表达式
①#”符号有三种用途：一、
访问非根对象（struts中值栈为根对象）如OGNL上下文和Action上下文，
parameters.id[0]作用相当于request.getParameter(“id”) #request.userName相当于request.getAttribute(“userName”) #session.userName相当于session.getAttribute(“userName”) #application.userName相当于application.getAttribute(“userName”)
二、构造Map，如: #{‘foo1’:’bar1’, ‘foo2’:’bar2’}
②“%”符号的用途是在标签的属性值被理解为字符串类型时，告诉执行环境%{}里的是OGNL表达式
3、“”有两种用途(1)、在国际化资源文件中，引用OGNL表达式。(2)、在Struts2配置文件中，引用OGNL表达式：listUser.action?msg=”有两种用途 (1)、在国际化资源文件中，引用OGNL表达式。 (2)、在Struts 2配置文件中，引用OGNL表达式： {msg}
listUser.action?msg=${msg}
Spring
1、面向接口的编程
结构设计中分清层次和调用关系，每层只向外提供一组功能接口，各层间调用依赖接口而不是实现类；“面向接口的编程”中的“接口”是用于隐藏具体实现和实现多态的组件；接口实现的变动不影响各层间的调用关系
2、基本概念
（1）Spring是什么
Spring是一个开源框架，为了解决企业应用程序开发的复杂性而创建，是一个轻量级的IOC和AOP容器框架。
Spring的核心就是IOC和AOP，通过使用IoC能够降低组件之间的耦合度，最终，能够提高类的重用性，利于测试，而且更利于整个产品或系统集成和配置，通过AOP技术分离应用的业务逻辑以系统级服务进行内聚性的开发。
（2）IOC 控制反转
控制权的反转（转移），由容器控制程序间的关系（依赖对象的创建和维护）而不是由代码。
（3）DI （依赖注入）
是控制反转的一种实现方式，在IOC容器运行期间，动态地将某种依赖关系注入到对象之中。目的：创建对象并且组装对象之间的关系。
（4）AOP（面向切面的编程）
面向切面的编程，通过预编译和运行期动态代理实现程序功能的统一维护的的一种技术。
方式很类似filter，就是在程序正常的业务流中间像切面一样插入很多其他需要执行的代码，比如登录时候，在进入登录页面前写入日志，很常用的，尤其是跟数据库有关的，或者跟支付有关的程序肯定会在每一步前面插入日志。主要的功能是：日志记录、安全管理、事务管理、异常管理等。
3、Spring注入
Spring注入是指在启动Spring容器加载bean配置的时候，完成对变量的赋值行为。
（1）常用的注入方式
①设值注入
Spring配置文件
<beans>
<bean id="" class=""><property name="" ref=""/></bean>
<bean id="" class=""></bean>
</beans>
实现类（InjectionServiceImpl.java）：
private InjectionDAO injectionDAO;
public void setInjectionDAO(InjectionDAO injectionDAO){
this.injectionDAO = injectionDAO;
}②构造器注入
Spring配置文件：
<beans>
<bean id="" class=""><constructor-arg name="" ref=""/></bean>
<bean id="" class=""></bean>
</beans>
实现类（InjectionServiceImpl.java）：
private InjectionDAO injectionDAO;
public InjectionServiceImpl(InjectionDAO injectionDAO){
this.injectionDAO = injectionDAO;
}4、Bean
（1）Bean配置项
Id ,Class,Scope, Constructor-arg, Properties , Autowiring mode, lazy-initialization mode, Initialization/destruction method
（2）Bean的作用域
singleton:单例，指一个IOC容器中只存在一份；prototype：每次请求创建新的实例,request：每次http请求创建一个实例仅在当前request内有效,session：同上，session内有效,global session
（3）Bean的生命周期
定义
初始化：
实现initialzingBean接口,重写afterPropertiesSet方法
配置init-method
使用
销毁：
实现DisposableBean接口，重写destory方法
配置destroy-method
初始化和销毁的具体实现
①配置全局默认初始化、销毁方法
<beas xxxxxxxxxxx default-init-method="init" default-destory-method="destory">②实现initialzingBean接口,重写afterPropertiesSet方法；DisposableBean接口，重写destory方法
BeanLIfeCycle类中实现initiazingBean和disposableBean接口和重写afteproperties、destory方法：
public class BeanLifeCycle implements initilizingBean,DisposbleBean{
public void afterPropertiesSet(){}
public void destory(){}
}③配置init-method 和配置destroy-method
spring配置文件：
<bean id="BeanLIfeCycle" class="com.xxx.xxx.BeanLIfeCycle" init-method="start" destory-method="stop"></bean>
BeanLIfeCycle类中要定义方法：
public viod start(){}
public viod stop(){}(4)Aware
是什么：Spring中提供了以Aware结尾的接口，实现了Aware了接口的Bean在初始化后，可以获取相应的资源；
①ApplicationContextAware
spring配置文件：
<bean id="IApplicationContext" name="com.xxx.xxx.IApplicationContext" />
IApplicationContext类中的实现：
public class IApplicationContext implements ApplicationContextAware{
ApplicationContext applicationContext
public void setApplicationContext(ApplicationContext applicationContext) throws BeanException{
this.applicationContext= applicationContext;
}
}②BeanNameAware
spring文件配置：
<bean id="IBeanName" name="com.xxx.xxx.IBeanName">
IBeanName类中的实现：
public class IBeanName implements BeanNameAware{
String beanName;
public void setBeanName(String name){
this.beanName=name;
}
}（5）Bean的自动装配
NO:默认的方式是不进行自动装配，通过显式设置ref 属性来进行装配。
byName:根据属性名进行操作 即根据Id
byType容器试图匹配、装配和该bean的属性具有相同类型的bean根据指定的属性类型相同的Bean，如果有多个该类型bean则抛异常，如果没有找到该类型的bean则什么也不发生；即class
Constructor:与byType方式类似，不同之处是它应用于构造参数，如果没找到以构造器参数类型一致的bean，则抛出异常。即构造方法的参数
spring配置文件：
<beans xxxxx default-autowire="byName"或"byType"或" Constructor">
<bean id="autoWiringService" name="com.xxx.xxx.AutoWiringService"></bean>
<bean id="autoWiringDAO" name="com.xxx.xxx.AutoWiringDAO"></bean>
</beans>
autoWiringService类的实现：
public class AutoWiringService{
public class AutoWiringDAO autoDAO;
public void setAutoWiringDAO(AutoWiringDAO autoWiringDAO){
this.autoWiringDAO = autoWiringDAO;
}
public AutoWiringService(AutoWiringDAO autoWiringDAO){//Constructor自动装配
this.autoWiringDAO = autoWiringDAO;
}
public void say(String word){
this.autoWiringDAO.say(word);
}
}
autoWiriongDAO的实现：
public class AutoWiringDAO{
public void say (String word){
System.out.pritln("执行DAO");
}
}（5）Resources&ResourceLoad
所有的ApplicationContext都实现了ResourceLoad接口
针对资源文件的同一接口
classpath：
file：
http:
none：（默认classpath）
spring配置文件：
<bean id="IResouce" class="com.xxx.xxx.IResouce"></bean>
IResources类的实现：
public class IResources implements ApplicationContextAware{
private ApplicationContext applicationContext;
public void ApplicationContext (ApplicationContext applicationContext){
this.applicationContext= applicationContext;
}
public void resource()throws IOException(){
Resource resource = applicationContext.getResource("classpath:config.txt");
System.out.println(resource.getFilName());
System.out.println(resource.contentLength());
}5、Bean管理注解实现
（1）classpath扫描与组件管理
6、Schema-based AOP（基于配置的AOP的实现）
（1）AOP基本概念
（2）AOP通知（advice）
通知的执行顺序：
（3）Introductions（引入）
（4）基于配置的AOP实例
①引入jar包
1 Aop的核心包，即org.springframework.aop-xxx.jar
2 Spring的联盟包：aopalliance-1.0.jar
3 aspectJ相关的jar包：aspectjrt.jar aspectjweaver.jar
4 如果使用了动态代理，还需要添加cglib相关的jar包：cglib.zip
②xml配置文件
下面的是Spring的配置标签，beans里面几个重要的属性：
xmlns：是默认的xml文档解析格式，即spring的beans。地址是http://www.springframework.org/schema/beans。通过设置这个属性，所有在beans里面声明的属性，可以直接通过<>来使用，比如等等。
xmlns:xsi：是xml需要遵守的规范，通过URL可以看到，是w3的统一规范，后面通过xsi:schemaLocation来定位所有的解析文件。
xmlns:aop：这个是重点，是我们这里需要使用到的一些语义规范，与面向切面AOP相关。
xmlns:tx:Spring中与事务相关的配置内容。
<?xml version="1.0" encoding="UTF-8"?>
<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:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<bean id="audience" class="com.spring.test.aop.Audience"/>
<bean id="sax" class="com.spring.test.setter.Saxophone"/>
<bean id="kenny" class="com.spring.test.setter.Instrumentalist">
<property name="song" value="Jingle Bells" />
<property name="age" value="25" />
<property name="instrument" ref="sax"/>
</bean>
<aop:config proxy-target-class="true">
<aop:aspect ref="audience">
<aop:pointcut id="performance" expression="execution(* com.spring.test.action1.Performer.perform(..))"/>
<aop:before pointcut-ref="performance" method="takeSeats"/>
<aop:before pointcut-ref="performance" method="turnOffCellPhones"/>
<aop:after-returning pointcut-ref="performance" method="applaud"/>
<aop:after-throwing pointcut-ref="performance" method="demandRefund"/>
</aop:aspect>
</aop:config>
</beans>7、Spring事务
（1）事务的特性ACID
原子性：一个事务是最小的执行单元，不可再分。
一致性：事务操作必须是从一个一致性到另一个一致性
隔离性：事务的执行之间应该是互不影响的
持久性：事务对数据库的操作时持久的
（2）数据库事务并发带来的问题：
脏读：事务B在事务A的两次操作之间读取数据，读取的数据必定是不准确的
不可重复读：
幻读：
（3）事务隔离级别
（4）事务传播行为
（5）Spring提供的事务管理可以分为两类：编程式的和声明式的。
编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活方便。
①Spring提供的编程式的事务处理
Spring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义
TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager，我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。
我们使用编程式的事务管理流程可能如下：
① 声明数据源。
②声明一个事务管理类，例如：DataSourceTransactionManager,HibernateTransactionManger,JTATransactionManager等
③在我们的代码中加入事务处理代码：
TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try{
//do sth
transactionManager.commit(ts);
}catch(Exception e){transactionManager.rollback(ts);
}②Spring声明式事务处理
首先在/WEB-INF/applicationContext.xml添加以下内容：
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="mySessionFactory"/>
</property>
</bean>注：这是作为公共使用的事务管理器Bean。这个会是事先配置好的，不需各个模块各自去配。
下面就开始配置各个模块所必须的部分，在各自的applicationContext-XXX-beans.xml配置的对于事务管理的详细信息。
首先就是配置事务的传播特性，如下：
<!-- 配置事务传播特性 -->
<tx:advice id="TestAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="save*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="update*" propagation="REQUIRED"/>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="find*" propagation="REQUIRED"/>
<tx:method name="get*" propagation="REQUIRED"/>
<tx:method name="apply*" propagation="REQUIRED"/>
</tx:attributes>
</tx:advice>
<!-- 配置参与事务的类 -->
<aop:config>
<aop:pointcut id="allTestServiceMethod" expression="execution(* com.test.testAda.test.model.service.*.*(..))"/>
<aop:advisor pointcut-ref="allTestServiceMethod" advice-ref="TestAdvice" />
</aop:config>需要注意的地方:
（1） advice（建议）的命名：由于每个模块都会有自己的Advice，所以在命名上需要作出规范，初步的构想就是模块名+Advice（只是一种命名规范）。
（2） tx:attribute标签所配置的是作为事务的方法的命名类型。
如*为通配符，即代表以save为开头的所有方法，即表示符合此命名规则的方法作为一个事务。
propagation=”REQUIRED”代表支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。
（3） aop:pointcut标签配置参与事务的类，由于是在Service中进行数据库业务操作，配的应该是包含那些作为事务的方法的Service类。首先应该特别注意的是id的命名，同样由于每个模块都有自己事务切面，所以我觉得初步的命名规则因为 all+模块名+ServiceMethod。而且每个模块之间不同之处还在于以下一句：expression=”execution(* com.test.testAda.test.model.service..(..))”其中第一个代表返回值，第二代表service下子包，第三个*代表方法名，“（..）”代表方法参数。
（4） aop:advisor标签就是把上面我们所配置的事务管理两部分属性整合起来作为整个事务管理。
事务详解
下一步要进行的工作！——————–
SSH分开的实例！
Hibernate的关系！
spring的实例！
SSH合并的实例！
Uiautomator Api浅析
每条用例都要继承UiAutomatorTestCase类：
UiDevice
pressMenu(), pressBack(), pressHome(), pressSearch() ,pressDPadCenter(), pressDPadRight(), pressDPadLeft(), pressDPadUp(), pressDPadDown() ,pressDelete(), pressEnter(), pressKeyCode(), pressRecentApps(),click(),swipe(),getDisplayRotation() setOrientationLeft()… wakeUp(), sleep() ,dumpWindowHierarchy(), waitForWindowUpdate()
UiSelector
主要是通过一定查询方式，定位到所要操作的UI元素。
一般UI元素均可通过以下API定位：text(),className() ,Description()，packageName(),
UiScrollable
UiObject
UiObject可代表页面的任意元素，它的各种属性定位通常通过UiSelector来完成。
比较常用的Api如clickAndWaitForNewWindow()，表示点击该元素，并且等待新新窗口的展示完毕。
UiCollection
uimap的实现方式：UIMap运行前将编译好的jar包，导入到手机。在运行的时候UIMap会解析
2065
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
