Spring 学习 笔记

3月21日
Design Pattern(设计模式)
什么是设计模式?
设计模式是一种比框架更小的程序设计结构,他是程序员在不断的软件开发当中总结出来的程序编写,设计方式,所以模式就像一个模板,可以应用于我们的实际开发当中
模式四要素:
1 模式名称(pattern name): 一个助记名,它是有一两个词来描述模式 的问题,解决方案和效果
2 问题(problem): 描述了应该在保是时使用模式
3 解决方案(soultion): 描述了设计的组成成分,它们之间的相互关系及各自的职责和协作方式
4 效果( consequences): 描述了模式应用的效果及使用模式权衡问题.因为我们有些时候使用设计模式会牺牲一定的代价
设计模式优点:
1  提高软件可靠性,稳定性
2  提高软件的灵活性,可维护性,可读性,可扩展性,结构性
3  提高开发效率
注: 模式不是万能的,不要为了模式而使用模式
设计模式的历程:
设计模式最初是1993年初期,由四个人合著的,书名为<＜GOF>>--gang of four(四人团队),这本书中提到 的23种设计模式称之为GOF23
常用设计模式:
工厂设计模式是面向对象编程中最常用的设计模式之一,它被称为创建性模式,因为它被用来创建其他类
工厂实际上是一组模式的名称,这组模式的目的是创建类的,每个变体都能指定一个不同的创建,这些模式变体是:
静态(简单)工厂(Static Factory)       //方便是提供类对象及它的子类对象
抽象工厂(Abstract Factory)            //灵活性,可扩展性
工厂方法(Factory Method)                //在抽象类中定义创建对象的接口,创建对象的具体工作推迟到了类去
新建项目:  Static_Employee
工厂设计模式:
1 面向接口开发,可以使用接口制定原则,标准
2 代码统一管理
3 扩展灵活
23中设计模式的分类:
创建型(Creational)
对象型:用来创建对象
Factory Method
Abstract Factory
Singleton
结构型(Structural): 处理类或对象的组合,用来解决在创建系统结构性的过程中,或者对象进行合理有效的组合,以获得更大的结构的方法
Adapter
Bridge
Composite
Decorator
Facade
FlyWeight
Proxy
行为型(Behavioral):主要对类或对象怎样交互和怎样分配职责进行描述
Interpreter
Template Method
Chain Of Responsibiliy
Command
Iterator
Mediator
Memento
Observer
State
Strategy
Visitor
单例模式-----属于创建类,生产对象的
3 Singleton(单例设计模式)-----创建类
基本面试题
特点:
         每次产生的对象的地址,都是同一个
应用于:
             数据库连接,文件操作
写法:
1  饿汉式写法
1.1 在属性中 
  private static MyObject = new MyObject();
1.2 封闭构造,将无参构造修饰为private
1.3 提供public static 方法,返回MyObject地址,此方法一般命名为:
  public static MyObject getInstance()
  return obj;
2  懒汉式写法
2.1 在属性中 
  private static MyObject = null;
2.2 封闭构造,将无参构造修饰为private
2.3 提供public static 方法,返回MyObject地址,此方法一般命名为:
  public static MyObject getInstance()
  if(obj == null)
    obj = new MyObject();
  retrun obj;
饿汉与懒汉的区别:
饿汉: 先 new出自身的对象
懒汉: 判断后在new出自身对象,如果已经有对象,那么将返回第一次的对象地址
新建项目: Singleton
新建项目: Proxy
代理模式: 属于中介类,帮助处理类对象的相关操作
Spring
文档
docs/reference/html_singel/index.html
名词理解:
IoC=Inversion of Control               //控制反转
AOP=Aspect Oriented Programming       //面向方面编程
将主要代码,事务处理,异常处理.....
实现第一个Spring程序:
1 jar环境搭建:
dist/spring.jar Copy Tomcat/lib
2 新建项目: MyFirstSpring
3 配置文件: applicationContext.xml
4 程序:
目标,实现
com.zlvc.app
HelloWorld.java
5 修改配置文件
6 使用spring:
6.1 读取配置文件
初步理解Spring:
Spring是一个大工厂
作业:
将之前的Hibernate练习复习的同时,将Hibernate中的DaoFactory.java取消,使用Spring创建
示例:
dao/UserDao.java
dao/hibernate/UserDaoHibernate.java
model/User
test/UserDaoTest.java
1 编辑applicationContext.xml
<bean id="uDao" class="com.xxx.dao.hibernate.UserDaoHibernate" />
2 编辑UserDaoTest.java
读取Spring配置文件
BeanFactory bean = context;
UserDao uDao = (UserDao)bean.getBean("uDao");
新建项目: Spring_student
3月23日
Spring Framework
JavaEE软件工程师:
1 Java SE
  java.lang.*;
  java.util.*;
  java.io.*;
     用户管理系统
  IM
2 Database(MySQL)
3 JDBC+DAO+Factory
     超市业务管理系统(前,后台)
4 CSS+DIV+HTML(XHTML)+JavaScript(Ext)-----昆山--家底财务管理系统(纯jsp+jdbc+dao   +factory)
5 JSP + JavaBean----(移动业务计费系统)
6 Servlet+MVC
     学习笔记发布系统
    公司网站发布系统(jsp+servlet+javabean)
(CMS系统----内容管理系统)
7 Struts1.3了解Struts2.0
  (VCM(DAO+Factory))
      1  在线项目(eriching.zlvc.edu.cn:8080)
      2  大唐任务管理系统
8 (Linux)Hibernate
9 Spring
4月17日考试到19号结束
Spring特点:
1  以非入侵方式来管理项目代码
2  提供了和其他很多成熟框架集成的接口,如:Hibernate,Struts的集成
3  为(IoC和AOP)用于架构多层JavaEE系统框架
Java EE三层架构:
  表现层                业务逻辑层                          数据持久层
struts      spring           hibernate
Spring模块简介:
1 Core Container(核心容器): 提供Spring框架的基本功能.主要组件:BeanFactory(一种工厂模式实现). BeanFactory使用IOC(控制反转)模式将应用程序的配置和依赖性规范与实际的应用程序代码分开
2 Spring Context: 一个配置文件,向Spring框架提供上下文信息.Spring上下文包括企业服务如:JNDI,EJB...
3 Spring AOP: 它直接将面向方面的编程功能集成到了Spring框架中
4 Spring DAO: JDBC DAO抽象层提供了有意义的异常层次结构,可用该结构来管理异常处理和不同数据库供应商抛出的错误信息,通过它的处理,程序员极大的降低了需要编写的异常代码数量(连接关闭,打开...)
5 Spring ORM: 方便的对ORM 如:
Hibernate,iBatis, JDO等的支持
6 Spring WEB: Web上下文模块建立在应用程序上下文模块之上,为基于Web的应用程序提供了上下文,同时提供了:Struts,WebWork...MVC框架的支持
Spring在Business Layer的作用:
降低业务逻辑层与系统其他部分的耦合度
扩展性强
使代码更为简洁,增加复用度,提高开发效率
Spring历史:
Spring是从2003年2月开始的开源工程,但Spring有较长的历史根基,这个开源工程是起源自Rod Johnson在2002年后期出版的<<Expert One-on-One J2EE设计与开发>>书中的基础代码
IOC(Inversion of Control)
IOC(控制反转)是一种编程思想,它的主要作用是协调系统中相关组件之间的依赖关系(类之间的调用 关系),这种关系的协调可以能够大大的提高系统的可维护性和可扩展性,是软件可插拔性的保证
在软件开发中,IOC意味着将你设计好的类交给系统(Spring,或其他IOC框架)去控制,而不是在你的类内部控制
概念:类与类之间的关系将由容器处理,一个类在需要调用另一个类时,只要调用 另一个类在容器中注册的名字就可以得到这个类的实例,这与传统的编程方式有了很大的不同,"不用你找,我来提供给你",即为"控制反转"
新建项目: Spring_Layer
依赖注入:
其核心思想就是要将具体类之间的依赖,尽量转换抽象依赖,然后通过Spring的配置
<ref bean="id_name" />
自动完成注入(传参)
优势:
程序设计完毕,再也不要修改,重新编译,以后只需要修改Spring配置文件即可
实际上理解:
IoC与DI是同一个概念
作业:
模拟员工,管理者----同属于员工类型,实现理解IoC,DI
Spring_work
3月24日
构造注入:(为类的构造传参数)
新建项目: Spring_Constructor
基本的IoC(DI)配置结束:
1 <bean id="diy_name" class="xxx.xxxClass" />
     会自动调用此类无参构造
2  注入(传参):
2.1 <property name="kit" >
    <ref bean="kit" />
    </property>3
3 注入(构造):
<constructor-arg index="0" value="xx" />
IoC的优势:
可以大大降低类与类之间的依赖耦合
松耦合:
类与类之间几乎没有依赖耦合,但在实际使用时,又可以组合为一个整体
Spring数据访问(ORM,DAO)
Spring数据访问:
一 Spring + Hibernate
新建项目: Spring_Hibernate
将之前的: Hibernate项目源码Copy过来
Spring的ORM模块对于Hibernate有着很好的支持,可以大大减少Hibernate重复性代码
是:
1 HibernateDaoSupport:
public abstract calss org.springframework.orm.hibernate3.support.HibernateDaoSuppert
2 HibernateTemplte:
org.springframework.orm.hibernate3.HibernateTemplate进行支持
如何使用:
将xxDaoHibernate extends HibernateDaoSupport implements xxDao
Spring与Hibernate整合
默认:
Hibernate: hibernate.cfg.xml
Spring: applicationContext.xml
整合后只有:
applicatinContext.xml
在实际使用中便于分类:
applicationContext-dao.xml
配置文件主要内容:
1 配置 dataSource
2 配置 sessionFactory
<bean id="sessionFactory" class="" org.springframework.orm.hibernate3.LocalSessionFactoryBean
3 使用 xxxDaoHibernate
  并注入  sessionFactory
使用MyEclipse进行Spring +　Hibernate 的开发
MyEclipse
www.myeclipseide.com
主要对eclipse进行了多种企业级别插件的整合
MyEclipse下进行Spring + Hibernate整合:
1 新建Web Project
2 新建数据源:
配置数据源: Window---->show View--->other--->MyEclipse Database--->DB Browser
3 添加Spring支持
4 添加Hibernate支持
注:Spring的jar包与Hibernate有冲突:
需要手工删除冲突包:
rm -rf asm-2.2.3.jar
5 编写model,dao,hibernate
作业:
将之前的Hibernate项目交给Spring进行管理,至少移植3个
Spring_Inherit
Spring_one_to_one
Spring_SetTest
MyEclipse的安装过程:
1 解压
tar javf myeclipse_7.0.tar.bz2
2   新建一个文件夹
将解压后的Myeclipse放到文件夹下
3 修改配置文件:
# vi myeclipse.sh
/opt/myeclipse...
4 使用终端进入
# sh myeclipse.sh    //打开MyEclipse
选择任务栏
打开 vi SN  //注册
1 MyEclipse ---> Subscription Information
2 Window ---> show View ---> other --->MyEclipse Database--->DB Browser
1  选择MySQL
2 修改为 localhost:3306/库名
3 root
4 无
5 选择一个MySQl的jar包
6 记住密码
7 测试
8 finish
3 右点创建项目 ----为5.0
4 右键----MyEclipse---Add Spring Capabllltles---前四个Spring 2.5 Web Libraries...,后三个--->点小圆点Copy checked Library...
MyEclipse ---> add Hibernate Capabllltles---第二个Copy---> 第二个---> sessionFactory(都选第二个)--->dataSource--->去点钩---> 下一步--->Replace
到home下删除包：asm-2.2.3.jar
3月25日
Spring + Hibernate的查询方式:
1 this.hibernateTemplate().find(hql);
便于查询所有记录

2 Query query = this.getSession().createQuery();
    便于条件查找

条件查找,使用HibernateCallback实现
3 this.hibernateTmplate().excute(
     new HibernateCallback(){
public Object doInHibernate(Session session){
Query query = session.createQuery(hql);
}
}
);
新建项目: Spring_Students
SSH框架整合:
1 整合步骤: SSH
1.1 Spring + Hibernate
1.2 Struts + Spring
总结: Spring ----> Hibernate ----> Struts (SSH)
使用MyEclipse进行整合:
实现对User类的CRUD:
Web Project  ----SSHUserDemo
1 add Spring
2 add Hibernate
3 model(com.eriching.model/User.java)
User.hbm.xml     //MyEclipse
4 dao
5 service    //避免DAO层与表现层的耦合
如何编写service层?
里面的接口与DAO是完全一样的
命名的方式为:xxxManager:
例: UserManager    //接口
  UserManagerImpl
目录结构为: service/UserManager.java
         service/impl/UserManagerImpl.java
service层的Spring配置文件:
applicationContext-service.xml   //作用产生xxxManager对象,为Struts Action调用做准备
6 add Struts
6.1 new Struts ActionForm
    com.eriching.webapp.form/UserForm.java
Form type: com.eriching.webapp.form.UserForm
new Struts Action
type: com.eriching.webapp.action.UserAction
applicationContext-struts.xml
7 Struts + Spring
7.1 编辑 struts-config.xml
8 配置 web.xml
9 编写 jsp测试
index.jsp
明天作业:
将之前的Hibernate+Struts的学生CRUD修改为SSH
SSHUSer
注: 两个模块
1 管理员: login
2 学生: CRUD
调试:
1 applicationContext-dao.xml
2 applicationContext-service.xml
3 applicationContext-struts.xml
web.xml
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝SSH框架整合详解＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
操作步骤（见SSH整合步骤_For_MyEclipse7.0.pdf）
1 add Spring
2 add Hibernate
3 model(com.eriching.model/User.java)
   user.hbm.xml   //MyEclipse 反向生成
进入DB Browser选择一个你需要的数据库，选择table，右击New table－－－table name为user
选择add添加user表的属性
右击user表－－HIbernate Reverse（倒数第四个）
选择browse－－－你的项目model－－－create POJO选中（默认）
id（uuid.hex）下一步
选择user －－－id（uuid.hex）
选择finish
是否切换为xxx界面选择NO（否）
4 DAO
browse－－－－HibernateDAO Suppert
Add －－－userDAO
5 service  ／／避免持久层（DAO）层与表现层的耦合
如何编写serice层？－－－－里面的接口与dao是完全一样的
命名的方式为xxxManager：
UserManager  ／／接口
  UserManagerImpl
目录结构：service/UserManager.java
service/impl/UserManagerImpl.java

service层的Spring的配置文件：
applicationContext－－－service.xml
//作用产生xxxManager对象
//为struts Action调用做准备

6 add Struts
右击项目＝＝＝add Struts＝＝＝Struts 1.3
修改项目名（公司名）ApplicationResoltrces空的文件
6.1 new Struts ActionForm
com.eriching.webapp.form/UserForm.java
选择other  struts1.3 Form
名字：UserForm
Form type: com.erching.webapp.form.UserForm
Form Properties
Add添加属性－－finish
new Struts Action
other----Struts1.3Action---next---Path /user---->type:com.eriching.webapp.action.UserAction---browse----userform
input source(错误跳转)：index.jsp
Forwards：添加成功与失败的跳转页面
在UserAction中写入连接
查看UserAction代码
新建applicationContext-struts.xml(写法讲究)
7 struts+Spring
7.1编辑struts-config.xml
pdf第三页的5.1粘贴到applicationContext-struts.xml
8 配置web.xml
将5.3的代码粘贴到web.xml
9 编写jsp测试
10 myeclipse＋tomcat连接
服务器－－－－－config server
servers－－－tomcat－－－tom6.0x----enable----点击browse找到自己的Apache－tomcat
－－点击OK
发布项目：服务器旁边－－－选择项目－－－add－－－选择服务器－－－finish－－ok
3月27日
type="org.springframework.web.struts.DeleqatingActionProxy"
Bean的作用域:
<bean id="xx" class="pack.class" scope="prototype" />
1 prototype     //每次创建一个实例
2 singleton     //每次只有一个实例(默认)
3 session(web.xml 加入支持<listener>)
<listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>
4 requet
5 global session   //不过它仅仅在基于portlet的 web应用中才有意义
local与bean的区别:
<property ref bean="xxx">
<ref bean>是为全局bean;
<ref local>是为本 xml 文件中的 bean
作业:SSH至少5遍练习,尽量不看Pdf
明天: Spring DAO,AOP
3月28日
SSH分页实现:
主要使用: Hibernate实现:
String hql = "From POJO";
Query query = this.getSession().createQuery();

//第一条记录的起始位置
//cp-1是因为hibernate的第一条记录为0
query.setFirstResult(cp-1)*pageSize);

//返回记录的最大数量
query.setMaxResults(pageSize);
作业:将之前的Struts_PageDemo升级为SSH分页实现:SSH_PageDemo
在原项目: SSHUserDemo中添加
SSH整合结束
2 Spring DAO模块:
1 extends JdbcDaoSupport
org.springframework.jdbc.core.support.jdbcDaoSupport;
extends jdbcDaoSupport implement xxxDao
2 使用: getJdbcTemplate()
3 配置
3.1 配置dataSource
3.2 在DAO中注入dataSource
new Project Spring_DAO
实现 对Student的CRUD:
src/com.eriching.model.Student.java
src/com.eriching.dao.StudentDao.java
src/com.eriching.dao.jdbc.StudentDao.java
src/com.eriching.test.StudentDaoTest.java
src/appplicationContext-dao.xml
Spring Aop(Aspect-Oriented Programming)
三 AOP
1 什么是AOP?
AOP是OOP的延续,是Aspect Oriented Programming的缩写,意思是面向方面编程,它最早来源于分散关注的思路(separation of concerns). AOP实际是GoF设计模式的延续,最终目标是为了软件项目中的主要逻辑代码(如:数据库操作)和辅助功能(如:操作数据库时实现事物处理)代码进行解耦合.
2 使用AOP的优势?
采用AOP之后会大大提高开发效率,有效地降低软件的复杂性,而且在的清晰性,模块,可测试方面也会取得很好的提升
3 通过回顾之前的jdbc代码,体验需要的必要性
3.1  nonaop    //重复代码多,维护较复杂
3.2 aopproxy   //使用了代理模式解决以上问题
3.3 使用Spring实现 AOP
主要使用:
MethodInterceptor   //方法拦截器
org.aopalliance.intercept.MethodInterceptor
具体就是可以拦截程序运行的方法,并且加入对应的其他方面代码,比如:事务处理,日志处理......
2 配置在applicationContext.xml中定义动态代理
3月30日
本周实践SSH:
一边项目,一边设计模式,EJB,JBoss
程序模块:
1 用户登录
2 用户注册,管理
3 用户的发贴
分析数据:
user表 ----用户登录模块,注册,管理
post_type表 ----记录论坛版块数据
id, type
1 流行音乐
2 摇滚音乐
post_preview表 ---- 贴子主题的预览
id
title
user
post_date
post_lastdate
post_type_id   //有两个外键
post表 -- 记录BBS中所有的发贴记录:
id
content
xx
xx
项目要求:
标准的SSH:
表现层:使用Struts标签库
项目流程:
名称: SSH_BBS
1  建库
2 搭建SSH开发环境 ----User表测试成功
3 贴子
com.xxx.app.user.dao.model.xxx
com.xxx.app.post.dao.xxx
vi /etc/my.cnf
/etc/init.d/mysqld restart
/opt/apache-tomcat-1.6.0/bin/sh shutdown.sh     //重启tomcat
Linux MySQL中文乱码
1 vi /etc/my.cnf
[mysqld]
character-set-server     = utf8
default-character-set    = utf8
2 /etc/init.d/mysqld restart
3 mysql -uroot -p
>drop database ssh_bbs;
>create database ssh_bbs;
使用过滤器