不乱于心, 不困于情. 不畏将来, 不念过往.如此,安好~
深谋若谷, 深交若水. 深明大义, 深悉小节.已然,静舒~
善宽以怀, 善感以恩. 善博以浪, 善精以业.这般,最佳~
勿感于时, 勿伤于怀. 勿耽美色, 勿沉虚妄.从今,进取~
无愧于天, 无愧于地. 无怍于人, 无惧于鬼.这样,人生~
Struts2: 基于mvc模式的应用层框架!
主要是作为控制层组件,javabean, jsp!
Hibernate: 持久层组件,简化jdbc操作!
Spring: 主要有六大模块功能
事务管理!
与其他框架整合!
Mvc开发模式:
基于mvc模式的项目分层!
Spring , 春天来了!
框架,都会预先实现一些功能,给开发人员开发提供便利!
提高开发效率、提升程序可扩展性、健壮!
高内聚、低耦合:
类内部的关系越紧密越好,类与类的关系越少越好!
非侵入式设计:
侵入式设计:
引入的组件对现有的类的结构会有影响,这种就是“侵入式设计”的组件!
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…
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>
<bean id="userService" class="cn.itcast.service.UserService"> <property name="userDao" ref="userDao">property> bean>
<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(); } |
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">
<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) 工厂
* 静态方法
* 非静态方法
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. 注解, 开发方便
(简化配置,不利于后期维护,如果修改对象创建、关系处理,需要改代码!)
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模块的支持
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对象),传入事件处理器方法参数中, 这样就可以根据业务逻辑,判断是否执行目标对象方法或扩展功能!
也叫”子类代理”
当目标对象没有实现接口,就不能使用jdk提供的代理,可以以子类的方式实现!
在运行时期动态在内存中构建一个子类对象的方法,从而对目标对象扩展,这种就是cglib代理!
Spring也支持cglib代理,核心包中已经包含此功能!
如:
public class UserDao { }
public class $Cglib_my_class extends UserDao {}
总结:
1. 目标对象可以不实现接口
2. 目标类不能为final, 如果为final报错
3. 方法如果为final/static, 不会被代理拦截! 会直接执行目标对象方法 !
在SpringAop编程中,
如果目标对象有实现接口,spring使用jdk提供的代理生成代理对象!
如果目标对象没有实现接口,使用cglib代理!
如果目标没有实现接口、且为final , 不能进行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编程:
关注点代码与业务代码分离!(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: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. 执行代理对象的方法,在运行时期,动态植入“切面”类中的“通知”!
步骤:
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">
<bean id="userDao" class="cn.itcast.f_aop_xml.UserDao">bean>
<bean id="aop" class="cn.itcast.f_aop_xml.TransactionAop">bean>
<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配置没有提示
学习了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 初步整合
程序中两种事务管理方式
JDBC事务控制:
con.setAutoCommite (false); 设置事务手动提交
Hibernate中事务控制:
session.beginTransaction(); 开启事务
优缺点:
1. 事务控制精确
2. 事务代码,与业务逻辑处理代码,耦合在一起!
事务代码,不能共用! 重新写事务控制操作!
开发效率低,不便于维护! (不想用事务,要改代码!)
特点:
1. Spring提供的声明式事务管理,用到Aop概念!
2. 对指定的方法添加事务控制,这里只需要配置即可!
3. 修改事务控制实现或删除事务控制操作,只需要移除xml事务相关配置!
注意:
只能对某个方法应用事务! (因为“切入点表达式”拦截的是方法,控制不了方法内部代码!)
所以,Spring声明式事务管理,即为粗粒度的事务控制!
声明式事务管理器类:
Jdbc:
DataSourceTransactionManager 管理jdbc中事务控制
Hibernate:
HibenateTransactionManager 管理hibernate中事务控制
|
事务控制在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">
<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>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource">property> bean>
<bean id="deptDao" class="cn.itcast.a_tx_jdbc.DeptDao"> <property name="jdbcTemplate" ref="jdbcTemplate">property> bean>
<bean id="deptService" class="cn.itcast.a_tx_jdbc.DeptService"> <property name="deptDao" ref="deptDao">property> bean>
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource">property> bean>
<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>
<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. 开启
|
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的保存方法
}
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
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">
<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>
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource">property>
<property name="hibernateProperties"> <props> <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialectprop> <prop key="hibernate.show_sql">trueprop> <prop key="hibernate.hbm2ddl.auto">updateprop> props> property>
<property name="mappingDirectoryLocations"> <list> <value>classpath:cn/itcast/entityvalue> list> property> bean>
<bean id="deptDao" class="cn.itcast.dao.DeptDao"> <property name="sessionFactory" ref="sessionFactory">property> bean>
<bean id="deptService" class="cn.itcast.service.DeptService"> <property name="deptDao" ref="deptDao">property> bean>
<bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory">property> bean>
<tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="*" read-only="false"/> tx:attributes> tx:advice>
<aop:config> <aop:advisor advice-ref="txAdvice" pointcut="execution(* cn..*Service.*(..))"/> aop:config>
beans>
|
如下:
1. JDBC
Spring 提供了JdbcTemplate模板工具类,对原始的jdbc操作进行简化!
2. Hibernate
Spring 提供了对hibernate的sessionFactory创建的支持 (整合)
à 直接在dao中使用sessionFactory对象操作数据库
à 使用Spring提供的 HibernateTemplate 工具类操作数据库
优点: 对session的常用操作进行封装! 比较方便!
à (推荐)HibernateDaoSupport工具类
Dao类直接继承HibernateDaoSupport工具类即可
HibernateDaoSupport对hibernateTemlate类进行了封装
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种方式:
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 修改/添加