Java工程师培训课（十八【新的领域】）

夜光序言：

 

 

不乱于心,   不困于情.    不畏将来,     不念过往.如此,安好~

深谋若谷,   深交若水.    深明大义,     深悉小节.已然,静舒~

善宽以怀,   善感以恩.    善博以浪,     善精以业.这般,最佳~

勿感于时,   勿伤于怀.    勿耽美色,     勿沉虚妄.从今,进取~ 

无愧于天,   无愧于地.    无怍于人,     无惧于鬼.这样,人生~

 

正文：

框架概述：

Struts2:  基于mvc模式的应用层框架！

主要是作为控制层组件，javabean， jsp！

Hibernate: 持久层组件，简化jdbc操作！

Spring:   主要有六大模块功能

 事务管理！

 与其他框架整合！

 

Mvc开发模式：

基于mvc模式的项目分层!

 

 

1. Spring框架

Spring ,  春天来了！

 

1. 框架理解

框架，都会预先实现一些功能，给开发人员开发提供便利！

  提高开发效率、提升程序可扩展性、健壮！

1. 专业术语

高内聚、低耦合：

类内部的关系越紧密越好，类与类的关系越少越好！

非侵入式设计：

侵入式设计：

引入的组件对现有的类的结构会有影响，这种就是“侵入式设计”的组件！

Struts2:     侵入式设计！

Hibernate:   非侵入式设计！

非侵入式设计：

引入组件对现有的类的结构没有影响！

Spring, 非侵入式设计

  IOC 容器

Inversion of control  控制反转

控制反转容器!   -à 对象创建的问题！

解释：

User user = new User();  自己控制对象的创建

现在需要对象，自己不创建，交给外部的容器创建，叫控制反转！

IOC容器= bean.xml配置 + ApplicationContext容器类

DI,  dependency  injection 依赖注入

创建对象后，处理对象的依赖关系！

User  user = new User();

user.setAddress(..)  ;// 需要DI（依赖注入）

 

  Aop…

 

1. Spring框架

Spring 开源框架，提供的是一站式解决方案！

六大模块:

…..

 

 

1. Spring 第一个案例， 解决项目中如何创建对象

 

1) 引入jar文件 (3.2版本)

commons-logging-1.1.3.jar       【单独下载】

spring-beans-3.2.5.RELEASE.jar 【spring源码, bean节点管理】

spring-context-3.2.5.RELEASE.jar      【spring上下文类】

spring-core-3.2.5.RELEASE.jar         【IOC容器】

spring-expression-3.2.5.RELEASE.jar    【spring表达式】

 

注意：

使用的版本Spring3.2

在这个版本中，只有spring自身的核心功能，spring依赖的其他组件，需要单独下载！ 例如：日志jar文件，就需要单独下载！

 

2) 新建applicationContext.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"     xmlns:context="http://www.springframework.org/schema/context"     xsi:schemaLocation="         http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd">   </beans>

 

3) 配置

 

<!-- 创建Dao实例 --> <bean id="userDao" class="cn.itcast.dao.UserDao"></bean>   <!-- 创建Service实例 --> <bean id="userService" class="cn.itcast.service.UserService"> <property name="userDao" ref="userDao"></property> </bean>   <!-- 创建Action实例 --> <bean id="userAction" class="cn.itcast.action.UserAction"> <property name="userService" ref="userService"></property> </bean>

 

4) 测试

// 从IOC容器获取对象 @Test public void testApp2() throws Exception { // 容器对象(加载applicationContext.xml配置文件) ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml"); // 获取对象 UserAction userAction = (UserAction) ac.getBean("userAction"); userAction.execute(); }

 

 

 

2. Spring IOC 容器

创建bean细节：

1) bean在容器中的写法

2) bean声明周期

 

 

<?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:context="http://www.springframework.org/schema/context"     xsi:schemaLocation="         http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd">   <!-- 把对象加入IOC容器 -->   <!-- 细节1： id 与   name： id 不能以数字开头，不能含有特殊符号, 不能有空格、逗号等；  id 不能重复！ name 可以以数字开头，可以有特殊符合，如果name值重复，编译没有问题但运行报错！   <bean id="user" name="user2,user3 user4" class="cn.itcast.a_config.User"></bean> <bean name="user5" class="cn.itcast.a_config.User"></bean> <bean id="user6" class="cn.itcast.a_config.User"></bean> <bean id="user6" class="cn.itcast.a_config.User"></bean> -->   <!-- 细节2： (单例/多例)  --> <!-- scope="singleton"   默认表示单例！        prototype    多例 init-method=""      在创建完对象之后执行初始化方法 destroy-method=""   在调用容器类的destroy()方法时候，对单例的对象有效！ lazy-init="true"    延迟初始化 / 这个属性的设置只对单例有影响，对多例没有任何影响！ 单例的对象默认是在创建容器的时候就创建所有单例的对象，如果希望在第一次访问的时候创建单例的对象，就设置延迟初始化 Bean生命周期：    bean在xml中配置，       singleton  单例        1) 创建对象         如果有配置延迟初始化，          lazy-init=true  如果单例的对象有配置延迟初始化， 在创建容器之后，在第一次从容器获取对象的时候           创建单例的对象！        如果没有配置或延迟初始化为默认值, 单例的对象会在创建容器的时候创建对象     2) 执行初始化方法 , init-method配置的方法会执行     3) 调用容器destroy() 方法时候，容器在销毁单例对象的实例的时候，会调用destroy-method对应的方法        此时bean对象会被销毁！              prototype  多例         1) 每次在从容器获取对象的时候，都会创建新的对象         2) 每次创建完对象后，就执行初始化方法      3) java回回收不用资源(jvm gc)  --> <bean id="user"  class="cn.itcast.a_config.User"  init-method="init"  destroy-method="destroy_"  lazy-init="false"  scope="prototype"></bean>   </beans>

 

 

创建对象的几种方式

 

创建对象的几种方式：

1） 调用无参数构造器

2） 调用有参数构造器

3） 工厂

* 静态方法

<bean id=”’  class=””  factory-method=””/>

* 非静态方法

<bean id=”factory”  class=”..”>

<bean id=””  factory-bean=” factory”   factory-method=”实例方法” />

4)  反射

 

 

 

 处理对象的依赖关系

给对象属性赋值(DI, 依赖注入)，几种方式：

 1) 构造函数赋值

 2) set 方法注入值

* 普通字段赋值

* 集合属性 (list/map/property)

3) 案例

Dao/service/action实例，处理依赖关系

* 常用的通过set方法注入

* 内部bean

* p 名称空间

* 自动装配

* 注解

 

 

 

注解总结：

@Component  表示一个组件(类)，把当前组件加入ioc容器

 加入容器的组件的名称默认是类名第一个字母小写

@Component(“”)   指定加入ioc容器的组件类的类名

 

@Repository    标识是一个持久层的组件

@Service       标识是一个业务逻辑层的组件

@Controller     标识是一个控制层的组件

 

@Scope("prototype") 指定对象单例/多例

@Resource     1. 默认根据修饰的字段名称会取ioc容器找对象自动注入

找到后注入

  2. 如果名称没有找到，再根据类型查找  找到后就立刻注入

 

     如果改类型在ioc容器中有多个对象，报错！

  3. 根据类型也没有找到对象，报错！

 

@Resource(name =””) 会根据指定的名称去容器找对象自动注入

 

配置方式与注解方式:

1. 配置， 便于维护

(配置过多，比较繁琐)

2. 注解， 开发方便

(简化配置，不利于后期维护，如果修改对象创建、关系处理，需要改代码！)

 

 

3. Spring 与Struts整合

Spring与struts整合，关键点:

把action的创建，交给spring的ioc容器！

所以，需要引入jar文件：

struts2-spring-plugin-2.3.4.1.jar 【struts源码】

spring-web-3.2.5.RELEASE.jar 【spring源码】

 

整合完整步骤：

1.  引入jar

Struts核心jar

Spring

Core  核心       （5个）

Web  对web支持 (2个)

2. 配置

bean.xml

struts.xml

web.xml

struts2核心过滤器

启动时候，配置加载springIOC容器

 

3. Action 类

 

 

 

夜光任务：

1. 写简单案例，练习spring 、

* 搭建spring环境

* 测试OK

* dao/service/action

然后处理对象依赖关系，

* set方法注入值, 几种方式

* 注解

2. spring与struts整合，小案例

3. 优化前面项目，

融入spring功能！

目标：

1.代理模式

2. Aop编程

* 手动实现aop编程

* spring Aop 注解方式

* Spring Aop  XML 配置

* 切入点表达式语法详解

3. Spring 对jdbc模块的支持

 

1. 代理模式

概念

Proxy, 表示代理！ 提供了对目标对象另外的访问方式，即通过代理访问目标对象！

 

Java中代理：

静态代理

动态代理

Jdk 代理

Cglib 代理

Spring默认支持

静态代理

特点：

1. 目标对象必须要实现接口

2. 代理对象，要实现与目标对象一样的接口

 

需求：

IUserDao.java   dao接口

UserDao.java    dao实现

Void save();  // 保存实现

UserDaoProxy.java   dao代理类，对UserDao中功能进行扩展！

App

 

 

缺点：

1. 代理对象，需要依赖目标对象的接口！

       如果接口功能变化，目标对象变化，会引入代理对象的变化!

2. 对每一个目标对象，都要分别写一个代理类，麻烦！

(代理工厂)

 

动态代理

动态代理：

1. 通常说的动态代理，就是指jdk代理!

       因为是通过jdk的api在运行时期，动态的生成代理对象的！

2. 目标对象一定要实现接口,  代理对象不用实现接口!

 

JDK 生成代理对象的Api

|-- Proxy  

static Object

newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

 

参数loader :

当前目标对象使用的类加载器！

参数interfaces :  

当前目标对象实现的接口

参数 h:

接口类型，事件处理器.

当执行目标对象方法的时候，会触发事件； 把当前执行的方法(method对象)，传入事件处理器方法参数中,  这样就可以根据业务逻辑，判断是否执行目标对象方法或扩展功能！

 

 

 

 

 

Cglib代理

也叫”子类代理”

当目标对象没有实现接口，就不能使用jdk提供的代理，可以以子类的方式实现！

在运行时期动态在内存中构建一个子类对象的方法，从而对目标对象扩展，这种就是cglib代理！

Spring也支持cglib代理，核心包中已经包含此功能！

1. JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。如果想代理没有实现接口的类，就可以使用CGLIB实现。
2.  CGLIB是一个强大的高性能的代码生成包，它可以在运行期扩展Java类与实现Java接口。它广泛的被许多AOP的框架使用，例如Spring AOP和dynaop，为他们提供方法的interception（拦截）。
3.  CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。不鼓励直接使用ASM，因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

 

 

如：

public class UserDao { }

public  class   $Cglib_my_class  extends  UserDao {}

 

 

总结：

1. 目标对象可以不实现接口

2. 目标类不能为final， 如果为final报错

3. 方法如果为final/static, 不会被代理拦截！ 会直接执行目标对象方法 ！

 

 

代理总结

在SpringAop编程中，

如果目标对象有实现接口，spring使用jdk提供的代理生成代理对象！

如果目标对象没有实现接口，使用cglib代理！

如果目标没有实现接口、且为final , 不能进行aop编程，报错！不能生成代理！

 

 

 

 

 

 

2. Aop编程

public void add(User user) { Session session = null; Transaction trans = null; try { session = HibernateSessionFactoryUtils.getSession();   【关注点代码】 trans = session.beginTransaction();                   【关注点代码】   session.save(user);     // 业务   trans.commit();                                    【关注点代码】 } catch (Exception e) { e.printStackTrace(); if(trans != null){ trans.rollback(); } } finally{ HibernateSessionFactoryUtils.closeSession(session); }    }

 

Aop 编程，

主要是分离业务代码与关注点代码！

关注点代码，写一次，在执行业务代码时候动态植入关注点代码！

 

自己实现aop编程

 

aop编程, 注解方式

概念：

Aop编程：

关注点代码与业务代码分离！(jdk/cglib代理)

关注点：

重复执行的代码, 也叫关注点代码!

切面：

关注点代码形成的类，就叫做切面

springAop编程，也叫面向切面编程！

   Aop: Aspect Object Programming 面向切面编程!

 

举例，哪些是切面？

事务，权限控制, 日志…

 

切入点表达式

拦截方法，给方法所在的类，生成代理对象！

Spring在初始化容器的时候，会根据切入点表达式的规则，会符合拦截规则的方法所在的类生成代理对象！

 

 

使用Aop开发步骤：

1. 引入aop 相关 jar文件

(aspectj 在spring之前，面向切面开发的公用组件)

aopalliance.jar               【spring-framework-2.5.6\lib\aopalliance】

aspectjrt.jar    【spring-framework-2.5.6\lib\aspectj】

aspectjweaver.jar             【spring-framework-2.5.6\lib\aspectj】

spring-aop-3.2.5.RELEASE.jar    【Spring3.2源码】

 

2. 引入aop名称空间

 

<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"     xmlns:aop="http://www.springframework.org/schema/aop"     xsi:schemaLocation="         http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd         http://www.springframework.org/schema/aop         http://www.springframework.org/schema/aop/spring-aop.xsd">   <!-- 开启注解扫描 --> <context:component-scan base-package="cn.itcast.e_aop_anno"></context:component-scan> <!-- 开启aop注解 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy>   </beans>

 

3. 开启aop注解

<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

 

4. 使用Aop相关注解

 

@Aspect      指定一个类为切面类

（切面类也需要实例化）

（切面类中的方法，也叫做通知）

@Before        前置通知  【在执行目标对象方法之前执行】

@After    后置通知  【在执行目标对象方法之后执行】

@AfterReturning    返回后通知  【在执行目标对象方法结束后执行， 出现异常不执行】

@AfterThrowing    异常通知   【在执行目标对象方法出现异常时候执行】

@Around          环绕通知   【环绕目标方法执行】

 

@Pointcut      定义一个切入点表达式变量  （后面使用这个切入点表达式的时候，直接引用方法名即可）

 

 

Spring生成代理对象的过程？

1. 创建容器对象的时候， 根据“切入点表达式”拦截的类，生成代理对象；

2. 如果目标对象有实现接口，使用jdk代理！

3. 如果目标对象没有实现接口，使用cglib代理！

4. 从容器获取代理后的对象

5. 执行代理对象的方法，在运行时期，动态植入“切面”类中的“通知”!

 

 

aop编程, XML配置方式

步骤：

1. 引入aop 相关jar文件

2. bean.xml  引入aop名称空间

3. Aop配置

 

<?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:context="http://www.springframework.org/schema/context"     xmlns:aop="http://www.springframework.org/schema/aop"     xsi:schemaLocation="         http://www.springframework.org/schema/beans         http://www.springframework.org/schema/beans/spring-beans.xsd         http://www.springframework.org/schema/context         http://www.springframework.org/schema/context/spring-context.xsd         http://www.springframework.org/schema/aop         http://www.springframework.org/schema/aop/spring-aop.xsd">   <!-- dao实例加入容器 --> <bean id="userDao" class="cn.itcast.f_aop_xml.UserDao"></bean>   <!-- 实例化切面类 --> <bean id="aop" class="cn.itcast.f_aop_xml.TransactionAop"></bean>   <!-- Aop相关配置 --> <aop:config> <!-- 切入点表达式定义 --> <aop:pointcut expression="execution(* cn.itcast.f_aop_xml.UserDao.*(..))" id="pt"/>   <!-- 切面配置 --> <aop:aspect ref="aop">   <!-- 【环绕通知】 --> <aop:around method="arroud" pointcut-ref="pt"/>   <!-- 【前置通知】 在目标方法之前执行 --> <aop:before method="beginTransaction" pointcut-ref="pt" />   <!-- 【后置通知】 --> <aop:after method="commit" pointcut-ref="pt"/>   <!-- 【返回后通知】 --> <aop:after-returning method="afterReturing" pointcut-ref="pt"/>   <!-- 异常通知 --> <aop:after-throwing method="afterThrowing" pointcut-ref="pt"/>   </aop:aspect> </aop:config>   </beans>

 

 

切入点表达式语法详解

切入点表达式：

拦截指定的类，生成代理对象！

 

execution(

modifiers-pattern?    拦截的方法的访问修饰符

ret-type-pattern                   方法返回类型，必须指定

declaring-type-pattern?             拦截的方法所在的类

 name-pattern(param-pattern)       拦截的方法（以及方法的参数列表）

     throws-pattern?)                  方法声明的异常

 

总结：

拦截，一定要指定到方法！

 

 

共性问题：

1. @Override报错

Jdk1.5 只支持父类方法的重写，不支持接口

Jdk1.6 修复这个问题

修改编译编译，改为1.6

2. xml配置没有提示

 

3. Spring 对jdbc模块的支持

学习了Spring的功能有：

Spring  Core   ioc容器

Spring Web    对web支持（与struts整合）

Spring Aop     面向切面编程

Spring Jdbc     对jdbc的支持

 

 

Spring 对象Jdbc的支持，

Spring 对jdbc的操作进行了简化！

提供了JdbcTemplate模板工具类，简化jdbc的操作！

 

如果想用spring jdbc功能，先引入jar文件：

spring-jdbc-3.2.5.RELEASE.jar     工具类包

spring-tx-3.2.5.RELEASE.jar       事务支持依赖包

连接池、数据库驱动包！

 

开发步骤：

1. 原始的jdbc操作代码

2. 对连接管理

3. 对jdbc操作进行简化

  à JdbcTemplate  工具类Api

 à JdbcTemplate与DataSource依赖关系

 

重点：

1. Aop, xml配置方式实现

2. Aop, 注解方式实现

-----------------------

3. 三种代理模式，练习

4. Spring 对jdbc支持

目标：

1. Spring声明式事务管理

2. Spring 与 Hibernate 整合

* Spring创建SessionFactory几种方式

* Spring对dao操作的支持

3. SSH 初步整合

 

1. Spring声明式事务管理

概念

 

1. 事务是一组操作的执行单元，相对于数据库操作来讲，事务管理的是一组SQL指令，比如增加，修改，删除等，事务的一致性，要求，这个事务内的操作必须全部执行成功，如果在此过程种出现了差错，比如有一条SQL语句没有执行成功，那么这一组操作都将全部回滚
2. 事务特性（ACID）
   • Atomic(原子性):要么都成功，要么都失败 
   • Consistent(一致性):数据应该不被破坏
   • Isolate(隔离性):用户间操作不相混淆
   • Durable(持久性):永久保存 
   •  

程序中两种事务管理方式

1.      编程式事务管理
2.        编写程序式的事务管理可以清楚的定义事务的边界，可以实现细粒度的事务控制，比如你可以通过程序代码来控制你的事务何时开始，何时结束等，与后面介绍的声明式事务管理相比，它可以实现细粒度的事务控制，例如jdbc,hibernate，spring中不提倡使用。

 

JDBC事务控制：

con.setAutoCommite (false);   设置事务手动提交

Hibernate中事务控制：

session.beginTransaction();     开启事务

 

优缺点：

1. 事务控制精确

2. 事务代码，与业务逻辑处理代码，耦合在一起!

事务代码，不能共用！ 重新写事务控制操作！

开发效率低，不便于维护！  (不想用事务，要改代码！)

 

 

1.      声明式事务管理  (在Spring中使用)
2.        如果你并不需要细粒度的事务控制，你可以使用声明式事务，在Spring中，你只需要在Spring配置文件中做一些配置，即可将操作纳入到事务管理中，解除了和代码的耦合， 这是对应用代码影响最小的选择，从这一点再次验证了Spring关于AOP的概念。当你不需要事务管理的时候，可以直接从Spring配置文件中移除该设置

 

 特点：

1. Spring提供的声明式事务管理，用到Aop概念！

2. 对指定的方法添加事务控制，这里只需要配置即可！

3. 修改事务控制实现或删除事务控制操作，只需要移除xml事务相关配置！

注意：

只能对某个方法应用事务！ （因为“切入点表达式”拦截的是方法，控制不了方法内部代码！）

所以，Spring声明式事务管理，即为粗粒度的事务控制！

 

 

  声明式事务管理器类：

Jdbc:

DataSourceTransactionManager   管理jdbc中事务控制

Hibernate:

HibenateTransactionManager     管理hibernate中事务控制

 

 

声明式事务管理 – JDBC

 

XML 配置方式实现

事务控制在Service层：

 

步骤：

1. 引入jar文件

Spring 核心

Spring Aop 切面编程

Spring-jdbc  / Spring-tx /  驱动包、连接池

2. dao/service

3. 配置

* 数据源

* JdbcTemplate

* Dao/Service

* spring声明式事务管理配置

(拦截service方法的执行，动态植入事务控制代码！)

4. 测试

Save();

Int i =  1/0;

Save();

 

<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" 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.xsd        http://www.springframework.org/schema/context          http://www.springframework.org/schema/context/spring-context.xsd          http://www.springframework.org/schema/aop          http://www.springframework.org/schema/aop/spring-aop.xsd          http://www.springframework.org/schema/tx        http://www.springframework.org/schema/tx/spring-tx.xsd">   <!-- 1. 数据源配置 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> <property name="initialPoolSize" value="3"></property> <property name="maxPoolSize" value="6"></property> </bean>   <!-- 2. JdbcTemplate配置 ,  注入数据源--> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"></property> </bean>   <!-- 3. dao实例，注入jdbcTemplate --> <bean id="deptDao" class="cn.itcast.a_tx_jdbc.DeptDao"> <property name="jdbcTemplate" ref="jdbcTemplate"></property> </bean>   <!-- 4. Service实例，注入dao实例 --> <bean id="deptService" class="cn.itcast.a_tx_jdbc.DeptService"> <property name="deptDao" ref="deptDao"></property> </bean>   <!-- 5. Spring声明式事务管理配置 -->   <!-- 5.1 配置事务管理器类 --> <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean>   <!-- 5.2 事务通知配置, 拦截到指定的方法后如何管理事务 --> <!-- find*  find开头的方法，是只读的事务 --> <!--   *    上面所有的方法都不满足时候，采用的事务控制规则 --> <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="find*" read-only="true"/> <tx:method name="get*" read-only="true"/> <tx:method name="*" read-only="false"/> </tx:attributes> </tx:advice>   <!-- 5.3 事务Aop配置 = 切入点表达式  + 应用上面的事务通知 --> <aop:config> <aop:pointcut expression="execution(* cn.itcast.a_tx_jdbc.*Service.*(..))" id="pt"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/> </aop:config>   </beans>

 

注解方式实现

步骤：

1. 引入aop相关包

 

2. 开启

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

 

3. 使用@Transactional  注解

在需要添加事务控制的方法上写这个注解

 

@Transactional

写到方法上， 表示当前方法应用事务控制

写到类上，  表示当前类的所有方法都会应用事务

写到父类上， 当执行父类的这个方法时候才应用事务！

 

 

 

事务属性

 

// 当前方法应用事务

@Transactional(

readOnly=false,      // 读写的事务，当修改数据时候用；如果查询就设置为true

isolation=Isolation.DEFAULT,  // 事务隔离级别

timeout=-1, // 事务执行的超时时间, -1 表示不超时

noRollbackFor=ArithmeticException.class,   // 遇到指定的异常不回滚

propagation=Propagation.REQUIRES_NEW      // 事务传播行为

)

 

事务传播行为:  

Propagation.

REQUIRES_NEW  当前执行方法必须在事务环境下运行！

且 当前执行方法始终开启一个新的事务！    

REQUIRED       当前执行方法必须在事务环境下运行！

如果调用当前方式时候已经有一个事务环境，当前执行方法会加入当前事务环境，就不开启新的事务；

如果调用当前方法时候没有事务环境，就开启一个新的事务!

SUPPORTS       支持事务环境！ 如果当前方法没有事务，也可以运行！

Never           当前方法不能再事务环境下运行！

 

案例：

插入部门信息，插入日志(日志)！

 

1. t_log  日志表

2. LogService.java   插入记录

insertLog()           REQUIRES_NEW   

不管当前执行方法有没有事务环境，都开启新事务！

3. DeptService.java

        REQUIRED

Void  Save() {

// 日志提示： 在插入部门….

insertLog();     // 始终插入

int  I  = 1/0;  

dao.save();  调用dao的保存方法

}

 

 

 

 

2. Spring 与 Hibernate 整合

Spring与Hibernate整合，

 * 单例的SessionFactory对象，交给spring的IOC容器创建！

*  事务管理，交给spring声明式事务管理器

 

 

 

演示步骤：

1. 没有整合案例

2. 整合

 

整合步骤：

1. 引入Hibernate/spring框架相关包

* hibernate jar

*spring – core

* spring – aop  

* spring – orm   对orm支持

      spring-jdbc-3.2.5.RELEASE.jar

spring-orm-3.2.5.RELEASE.jar

spring-tx-3.2.5.RELEASE.jar

2. hibernate.cfg.xml

3. dao/service

 

 

* Spring创建SessionFactory几种方式

<?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:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context" 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.xsd        http://www.springframework.org/schema/context          http://www.springframework.org/schema/context/spring-context.xsd          http://www.springframework.org/schema/aop          http://www.springframework.org/schema/aop/spring-aop.xsd          http://www.springframework.org/schema/tx        http://www.springframework.org/schema/tx/spring-tx.xsd">             <!-- 连接池, 通过spring管理 -->     <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">      <property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>      <property name="driverClass" value="com.mysql.jdbc.Driver"></property>      <property name="user" value="root"></property>      <property name="password" value="root"></property>      <property name="initialPoolSize" value="3"></property>      <property name="maxPoolSize" value="6"></property>     </bean>             <!-- Spring 与   Hibenate整合  (Spring创建SessionFactory) -->             <!-- 方式1： 直接加载hibernate.cfg.xml的方式，创建sessionFactory对象     <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">     <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>     </bean>      -->            <!-- 方式2： 连接池交给spring管理，其他配置还是写到hibernate.cfg.xml中      <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">       <property name="dataSource" ref="dataSource"></property>       <property name="configLocation" value="classpath:hibernate.cfg.xml"></property>      </bean>      -->            <!-- 方式3：(推荐) 所有的配置都在spring中完成-->      <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">       <!-- a. 注入连接池 -->       <property name="dataSource" ref="dataSource"></property>             <!-- b. hibernate常用配置： 方言、自动建表、显示sql -->       <property name="hibernateProperties">       <props>       <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>       <prop key="hibernate.show_sql">true</prop>       <prop key="hibernate.hbm2ddl.auto">update</prop>       </props>       </property>             <!-- c. 加载所有的映射(根据路径加载)       <property name="mappingLocations">       <list>       <value>classpath:cn/itcast/entity/*.hbm.xml</value>       </list>       </property>       -->       <!-- c. 根据目录加载所有的映射 -->       <property name="mappingDirectoryLocations">       <list>       <value>classpath:cn/itcast/entity</value>       </list>       </property>      </bean>       <!-- 创建dao实例 --> <bean id="deptDao" class="cn.itcast.dao.DeptDao"> <property name="sessionFactory" ref="sessionFactory"></property> </bean>   <!-- 创建service实例 --> <bean id="deptService" class="cn.itcast.service.DeptService"> <property name="deptDao" ref="deptDao"></property> </bean>     <!-- Spring声明式事务管理配置  -->  <!-- a. 事务管理器 -->  <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">   <property name="sessionFactory" ref="sessionFactory"></property>  </bean>    <!-- b. 事务通知 -->  <tx:advice id="txAdvice" transaction-manager="txManager">   <tx:attributes>   <tx:method name="*" read-only="false"/>   </tx:attributes>  </tx:advice>    <!-- c. Aop配置  = 切入点表达式  + 应用通知规则 -->  <aop:config>   <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn..*Service.*(..))"/>  </aop:config>     </beans>

 

 

 

* Spring对dao操作的支持

如下：

1. JDBC

Spring 提供了JdbcTemplate模板工具类，对原始的jdbc操作进行简化！

2. Hibernate

Spring 提供了对hibernate的sessionFactory创建的支持 (整合)

 

à 直接在dao中使用sessionFactory对象操作数据库

à 使用Spring提供的 HibernateTemplate 工具类操作数据库

优点： 对session的常用操作进行封装！ 比较方便!

à (推荐)HibernateDaoSupport工具类  

Dao类直接继承HibernateDaoSupport工具类即可

HibernateDaoSupport对hibernateTemlate类进行了封装

 

 

 

3. SSH整合

SSH 整合：

Spring  与  Struts 整合

à Action创建交给Spring完成

Spring  与  Hibernate整合

à SessionFactory创建，交给spring完成   （管理事务）

 

步骤：

1. 引入jar文件

Struts核心jar

Hibernate核心jar

Spring

SpringCore  核心jar文件 （5个）

SpringWeb  对struts支持（2个）

SpringAop  声明式事务管理（4个）

SpringORM  对hibernate支持 （3个）

Orm + jdbc + tx  jar文件

其他

驱动 + 连接池

 

2. 配置

Web.xml    配置struts核心过滤器 + Spring容器初始化

Struts.xml   配置访问路径与action类的映射关系

applicationContext-public.xml   Spring容器配置  【公用配置】

applicationContext-dao.xml     Spring容器配置  【dao配置】

applicationContext-service.xml   Spring容器配置  【service配置】

applicationContext-action.xml     Spring容器配置  【action配置】

 

 

3. 代码

cn.itcast.entity   实体类： 封装数据/业务

cn.itcast.dao        数据访问层接口： 定义功能

cn.itcast.dao.impl    接口实现：      功能实现

cn.itcast.service      业务逻辑层  （控制事务）

cn.itcast.service.impl  实现

cn.itcast.action       控制层：  接收请求数据、处理请求、返回结果视图标记跳转

 

 

任务：

Action中写add/update/delete/findById/showAll 方法

1. 数据要在页面输入

2. 查询到的结果要在jsp页面显示  

 

Struts2：   

    (web)作为控制层组件;

    Struts中Action动作类，处理请求、相应！

        ---> 请求数据自动封装（param拦截器）

        ---> 数据处理

             数据保存到域中!

             1) ServletActionContext 获取原始的ServletApi

             2) 通过ActionContext, 获取代表request/session/application的map对象

             3) 实现接口:RquestAware/...

        ---> 文件上传/下载

        ---> 拦截器

        ---> 数据效验

        ---> ...

Hibernate:

    (dao)  持久层框架！对orm进行了实现!

    ---> Session Api  操作数据库

    ---> 映射

        多对一

        ...

    ---> 对象状态/lazy/inverse/cascade/session缓存、二级缓存/list与iterator查询

 

    注意：

        如何在jsp页面访问对象，以及对象关联的数据？

        ---> 数据先查询出来

        ---> session先不用关闭(dao中不用关闭session)，jsp页面呈现后，再关闭

            Open Session In View

                在用户访问服务器时候，Open Session

                    【中间： 因为session没有关，所以可以访问对象关联数据（懒加载）】

                在服务器相应结束后(jsp呈现)， 再关闭session!

 

            实现： 自己写的Filter!

 

Spring:

    SpringIOC : 创建对象及DI！

    SpringAop : 切面编程！

                应用:

                    声明式事务管理！用到aop! aop原理是代理！

    Springweb : 与struts整合

                (SpringMVC)

    SpringOrm :  与hibernate整合！

    SpringJdbc : 对jdbc支持！

------------------------------------------------------------

------------------------------------------------------------

项目整体目标：

    1. (重点)SSH框架技能，熟练度！

    2. 业务了解！

    3. 项目中问题解决！

        团队

        架构

        技术细节

        bug解决

今天：

    1. 项目开发流程

    2. 项目环境搭建

        搭建过程

        Spring测试框架

        页面环境

 

------------------------------------------------------------

------------------------------------------------------------

 

（一） 需求分析

 

   CRM   Customer Realtion Manager!

         客户关系管理系统

 

   主要功能：

        

        部门信息 Department  (市场部/教学部)

        员工信息 Employee    (袁杰老师) (营销人员)

        客户资料 Customer    (王磊学员)

 

        客户跟进历史 :  记录每次跟进的历史记录： 主题、内容、效果等！

        客户移交记录 :  支持把某个营销人员根据的客户，进行移交给其他营销人员！

        客户资源池   :  对暂时不需要跟进的客户放入资源池！

                        ---> 把客户放入资源池

                        ---> 从资源池认领客户

        

        项目开发模式：

            瀑布模式

            螺旋模式

------------------------------------------------------------        

------------------------------------------------------------

        

（二） 项目设计   

 

    1. 数据库设计

        (设计库表、表关系)

 

    2. 系统架构设计

        （

            开发：

                CRUD 实现基本业务

                公用类，

                    1. 自己用

                    2. 给别人用

                公用组件

                平台开发

                面向解决方案开发

        ）

        (项目项目结构： 分层、引用组件及版本、工具类)

 

 

（三） 代码

    注意：

        1. 严格实现需求定义的功能！

        2. 写代码前，先阅读编码规范

        3. coding...

 

（四） 测试

 

 

（五） 实施部署

      1. 项目部署到客户服务器上

      2. 试运行

      3. 运行上线

 

（六）验收

初验、中验、终验

 

 

 

 

项目开发, 环境搭建:

 

整体步骤：

    1. 搭建Spring环境

       测试OK

    2. 搭建Hibernate环境

        测试OK

    3. Spring与Hibernate整合

    4. 项目引入Struts框架

    5. 与Spring整合

----------------------------------------

 

 

1. 搭建Spring环境

    

    1.1 新建web 项目

 

    1.2 引入jar

        项目中用到的Spring的jar文件：

 

        SpringCore 核心（5）

        SpringAop  切面编程（4）

        SpringOrm  持久层支持 （3）

 

        SpringTest  使用spring提供的测试方案(方便)

 

    1.3 bean.xml  主配置

        新建源码文件：source/bean.xm

 

    1.4 测试

        

2. 搭建Hibernate环境

 

    2.1 hibernate反向工程  (了解)

        作用：

            根据数据库的表、自动生成entity/*.hbn.xml/dao

        步骤：

            1. myeclipse， Db Browser ， 新建一个连接， 打开连接，测试

            2. 选中数据库，再选择表，右键： Hibernate Reverse Engineering  (反向工程)

                接下来，可以选择生成实体类、映射、dao！

        

        什么时候用？

            1. 当对hibernate开发比较熟练的时候用！

                --> 反向出来的，还需要需改部分

            2. 当项目建好表，需要简化操作，可以选择反向工程！

 

 

    2.2 引入jar文件

 

    2.3 (可选：)主配置文件： hibernate.cfg.xml         

             如果没有的话，需要在spring中实现配置！

 

    2.4  映射文件: Department.hbm.xml

        Department.java

        IDepartmentDao.java

        

        DepartmentDao.java

            用Spring对hibernate的支持工具类： HibernateDaoSupport

            注意：

                需要注入SessionFactory/HibernateTemplate!

 

        Department.hbm.xml

       

 

    2.5 整合环境

        bean-public.xml  公用的配置： sessionFactroy创建的支持

 

3. Spring 与 Struts 整合

    

    3.1 引入jar文件

    

    3.2 web.xml

        ---> struts核心过滤器

        ---> spring监听器

    

    3.3 bean.xml/struts.xml

        

 

    3.4 整合后，Action类配置写法

 

        整合后,struts.xml中action类的写法，2种方式：

        <package name="department" extends="struts-default">

            <!-- action类的写法，方式1： 从ioc容器中按照指定的名称获取对象

            <action name="dept_*" class="departmentAction" method="{1}">                    【方式1】

                <result name="success">/index.jsp</result>

            </action>

             -->

             

             <!-- 创建Action对象，会自动去容器中找属性注入！  -->

             <action name="dept_*" class="cn.itcast.web.DepartmentAction" method="{1}">      【类全名】

                <result name="success">/index.jsp</result>

            </action>

        </package>

 

   3.5 整合后，服务器启动，获取当前服务器创建的WebApplicationContext( IOC 容器)对象

 

        // 方式一：

// String key = WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE;

// ApplicationContext ac= (ApplicationContext) ActionContext.getContext().getApplication().get(key);

 

// 方式二（推荐）：

// 先获取servletContext，再根据servletContext对象，获取当前运行的容器对象

ServletContext servletContext = ServletActionContext.getServletContext();

ApplicationContext ac = WebApplicationContextUtils.getWebApplicationContext(servletContext);

 

        

4. 前端页面框架搭建

    美工设计好的静态页面：

        路径：

            模板\Admin\*.html

        核心：

            top.html/menu.html/index.html

    步骤：

        a. 拷贝Images、Js 、Styles文件夹到项目资源目录下(WebRoot/WebContent)

        b. WEB-INF/views/

                            |-- index.html

                            |-- top.html

                            |-- menu.html

                            |-- main.html  主页（框架集页面）

 

        c. 修改后缀为jsp、引入page指令

        d. common.jsp, 公用css

        e. 其他页面引入公用页面资源

 

        f. 左侧菜单使用JQuery-zTree-v3.4组件，显示树状视图

           参照模板写jsp页面!

 

 

-----------------------------------

-----------------------------------

夜光练习:

    1. ssh环境搭建

    2. 前台页面搭建

    3. 实现Department CRUD！

 

 

 

（一） 需求分析

 

   CRM   Customer Realtion Manager!

         客户关系管理系统

 

   主要功能：

        

        部门信息 Department  (市场部/教学部)

        员工信息 Employee    (袁杰老师) (营销人员)

 

        客户资料 Customer    (王磊学员)

        客户跟进历史 :  记录每次跟进的历史记录： 主题、内容、效果等！

        客户移交记录 :  支持把某个营销人员根据的客户，进行移交给其他营销人员！

        客户资源池   :  对暂时不需要跟进的客户放入资源池！

                        ---> 把客户放入资源池

                        ---> 从资源池认领客户

        

---------------------------------------------

问题：

    

    1. SSH 框架整合，运行报错？  (web项目)

 

        * 重启tomcat，看启动是否报错！  

            如果启动报错，访问404！

 

        * 先解决启动报错！

 

        * 先写Junit测试代码

            测试：Service代码能正常运行！

            确保Spring与Hibernate整合没有问题

 

        * spring与struts测试

            断点!

 

 

---------------------------------------------

 

一、部门模块开发

  

  1. 设计javabean

 

  2. 写映射

 

  3. dao接口/dao实现

 

  4. service接口/service实现

 

    测试：

        每写完一个service都必须要测试!

  

  ------------------------------

 

  5. Action、Jsp

    

        Action

            list()   列表展示

 

        JSP

            list.jsp  列表页面

            edit.jsp  修改/添加

 

 

 

 

 

 

 

 

结束语：生而无憾，那是不可能的~，只求无愧于心