今天主要实现的是员工信息的翻页设计，用AJAX实现的，接着实现了员工信息的删除实现，总结 一天的知识，感觉jQuery确实是十分有用的一门技术。

1.带复杂条件的分页：(非AJAX分页)

 

直接把deptid属性过滤加上会导致出现：org.hibernate.QueryException:

这时因为在 Employee 实体类中根本就没有 deptid 属性(并非指在 Employee 类中有该属性,而是要在映射文件中映射该属性).

解决方法：

在 EmployeeDao 中重写 Page<T> findPage(final Page<T> page, final List<PropertyFilter> filters) 方法, 以解决表单页 面的 deptid和实体类的

dept属性的对应问题

    注 意：1.增强 for 循环时, 不能 remove 其元素

        2.在 循环时删除集合的元素, 会改变集合的 size 属性

2.AJAX分页设计

 1．需要在EmployeeAction的对应方法中，返回JSON数据，在页面上进行解析即可

 2.实现过程：

     1.点击上一页连接时，需要使用AJAX分页：因为ajax分页时，页面没有刷新，

 下一页连接添加AJAX支持

<script type=”text/javascript”>

$(function(){

 $(“#nextpage”).click(function(){

 Var url=”${cp}/employee-list-2.do?pageNo=” + (parseInt($(“#pageNo”).val()) + 1);

var args = $(“:hidden:not(#pageNo)”).serialize();

$.getJSON(url,args,function(data){

$(“.pagebanner”).html(“共”+data.totalCount+”条记录&nbsp;”);

$(“#pageNo”).val(data.pageNo);

});

return false;

});

});

</script>

服务器端实现（employeeList2）

1.获取请求参数

String pageNoStr = request.getParameter(“pageNo”);

2.从页面获取PropertyFilter集合

3.调用service的findPage方法,得到分页数据Page对象

4.将page对象转化为对应的JSON数据格式。那么需要转化为什么样的JSON数据

{totalCount：，totalPages：，pageNo：，employees:[{employeid，：loginName：，gender:,...}] }

 5.返回ＪＳＯＮ数据

response.setContentType(“text/javascript”);

response.getWritter().print(jsonResult);

 

3.员工信息 删除功能

1.AjAX删除功能的实现：

 1.若当前页已经是最后一页，且当前记录是当前页的最后一条记录，则不能再请求当前页的信息， totalPages不能代表服务器端的总页数

2.Ajax 删除要实现的功能:

1. 弹出confirm(): 确 定要删除吗?

2. 若点击"否", 则文本框或下拉框的值恢复为刚才的默认 值: 使用隐藏域.

3. 若点击"是", 进行ajax 删除

4. 若 员工信息有外键关联时，注 意：通过 ajaxError 函数进行提示，弹出“不能删除该记录”

    关键代码：

4.查看员工的详细信息

 这样的功能实现在现在来说，已不难实现，我实现了一下，不难！还用了下插件！显示Employee 的头像！

 

                               员工的录入和查询（带 条件查询）

  今天做的是员工信息录入和服务器端的验证，目标是使用jQuery更熟悉，掌握分页设计，更好理解Hibernate的一些以前未用过的类中的一些方法。

 一． 员工的录入，并进行验证

1.显示员工的录入页面

1.用jQuery 的validator 为表单做前台验证

2.对登录名的Ajax 校验

3.使用jQuery 的blockUI 插件提示Ajax 操作

4.录入员工信息

2.服务器端的简单验证

 1.使用struts的validator框架

 2.以email为例，email非空，且符合email格式

3.员工录入服务器端的复杂验证

 1.数据库,EmployeeAction中，得到登录名

 2.对登录名的可用性进行验证，验证登录名在数据库中是否存在

 3.这时可以采用struts的声明式异常

4.使用py4j 解决把汉字转为对应的拼音: 佟刚--> tg, 张孝祥--> zxx, 黎活明--> lhm

 二．员工的查询

1.显示员工信息:AJAX分页

使用displaytag 分页显示员工信息，记 录不超过百万条。简单，使用。比如OA。

1．在tomcat的webapps目录下展示其实例。

2. OpenSessionInView：

1使用OpenSessionInView

 若Hibernate中某一个类的引用属性（也 包括集合属性）采取懒加载策略，则可能出现懒加载异常，但没有对其懒加载属性进行初始化，此时关闭Session，然后再来获取属性，就会异常

声明使用spring的声明式事务：

<aop:config>

 <aop:pointcut expression="execution(* cn.itcast.ems.service.*.*(..))" id="emsTxPointcut"/>

 <aop:advisor advice-ref="emsTxAdvice" pointcut-ref="emsTxPointcut"/>

</aop:config>

OpenSessionInView可以解决这个问题，因为OpenSessionInView的使用流程是：

 request à open session 并开始transaction –>controller à view(jsp)à

2.如何使用：

在web.xml配置：

3.缺点：

如果流程中的某一步被阻塞, 而这期间的 connection 却一直被占用不被释放. 例如输出页面时, 一方面可能是页面内容大, response.write的时间长; 另一方面可能是网速慢, 服务器与用户间传输时间久. 当大量这样的情况出现时,就有连接池连接不足, 造成页面假死现 象. 所以在内容多流量大的网站需慎用.

3.翻页相关的类:

1.Page: 与具体 ORM 实现无关的分页参数及查询结果封装

       2. PropertyFilter: 与具体 ORM 实现无关的属性过滤条件封装类, 主要记录页面中简单的搜索过滤条件

       3. HibernateDao: 扩展 SimpleHibernateDao, 功能包括分页查询, 按属性过滤条件列表:

              1.不带任何查询条件时, 需要使用的方法:

                     --countCriteriaResult

                     --setPageParameter

                     --findPage(Page<T> page, Criterion...criterions)

HibernateWebUtils

分页：

不带查询的分页

employee-list-1.do --> Action --> Service --> DAO   

2.查询条件的翻页:使用jQuery 的一个thickbox 插件完成查询页面的弹出

 1.jQuery的分页插件

 2.在获取第一页的内容以后，如何 把查询条件带到第二页

     --把封装了查询条件的List放到session域中，下一次从session中取。

       --把查询条件放在隐藏域中

3.携带查询条件

 使用jQuery提供的serialize（）方法携带查询条件（行不通）

   var url = this.href + “&” + $(“:hidden”).serialize();

    window.location.href=url;

 注意：上述方法在第一次不能起作用: 即不能再第一次把隐藏域中的参数带过去, 因为在第一次点击该链接时, href 的属性值已经固定了, 不能再发生变化,

而第二次点击时, 因为第一次已经改变了该属性的值, 所以好用

所以必须在第一次点击该链接之前让 this.href = this.href + "&" + $(":hidden").serialize(); 起作用

解决方案：

$("#criteria").attr("href", $("#criteria").attr("href") + "&" + $(":hidden").serialize());

今天就到这儿，明天continue！

    今天接着昨天的整合，由佟老师总指挥，基于xml配置的Action，这涉及struts整合.今天先把登陆实现了，最后使用两个插件把员工信息录入功能 实现，页面效果在当今还是主流的。

2.服务器端验证
  1.查询数据库，得到信息
  2.若用户名不存在，则提示用户名不存在
           errors.add("",new ActionMessage(" "));
     若用户名和密码不匹配，则提示用户名和密码不匹配
     若errors.isEmpty()为true,则登陆，并将其保存在session中，
         
     方法:
        使用 struts 的声明式异常来转发页面和显示提示信息.
        
        详细解决:
        由 EmployeeService 的方法抛出异常, Action 不进行处理, 而由 struts 框架根据当前的 action 节点配置来进行相应的处理:
               如果出现对应的异常, 会利用当前 excpeption 配置节点的 key 生成对应的 ActionMessage 对象, 再放入 ActionMessages 中,
              把页面派发到 input 对应的页面中,  在前台页面利用 <html:errors property="key"> 进行显示      
        

4.ReflectUtils类的作用：
  1.convertValue：beanUtils1.8提供了DateConverter
  2. PropertyUtils: 提供了读写 Bean 的属性的方法
  3. fetchElementPropertyToString: StringUtils.join 方法可以把指定集合的元素用分隔符链接起来
  4. getSuperClassGenricType: ParameterizedType


5.SimpleHibernateDao 类介绍：SimpleHibernateDao<T,PK extends Serializable> 说明：该类在service层中使用，
     T：Dao操作的对象类型
     PK：主键类型
  1.getIdName():
  2.distinct(List list):通过 Set 将不唯一的对象列表唯一化,主      要用于 HQL/Criteria 预加载关联集合形成重复记    录, 又不方便使用 distinct 查询语句时
     
6.CreateCriteria:
     createQuery(String queryString, Object... values)
7. ReflectionUtils
    1 convertValue: beanUtils 1.8 提供了 DateConverter
    2. PropertyUtils: 提供了读写 Bean 的属性的方法
    3. fetchElementPropertyToString: StringUtils.join 方法可以把指定集合的元素用分隔符链接起来
    4. getSuperClassGenricType: ParameterizedType

8. SimpleHibernateDao:
    1. getIdName: ClassMetadata 该类可以获取到对应的 class 的 hbm 配置文件的几乎所有信息
    2. 标准查询:
        -->创建 Criteria 对象: session.createCriteria(clazz);
        -->为 Criteria 对象添加查询条件: criteria.add(criterion);
        -->获取 Criterion 对象: 通过 Restrictions 来获取

9.struts的导航组件：struts-menu的使用方法：
     1. 把 struts-menu.war 文件复制到服务器下, 运行
    2. 在 struts-config.xml 文件中加入 struts-menu 插件
    3. 复制 struts-menu\WEB-INF\menu-config.xml 到 conf 目录下.
    4. 复制 struts-menu-2.4.3\struts-menu-2.4.3.jar 到 classpath 下
    5. struts-menu 的去除默认背景色问题:
        ①. 通过 jQuery: 把 left.jsp 页面的第三个 table 的 style="background-color:lightgrey" 属性清除
        ②. 通过修改默认的配置文件: 修改 struts-menu=2.4.3.jar net.sf.navigator.displayer 包的的 DisplayerStrings.properties 文件,
                  把  dd.menu.top=<table width\="150" style\="background-color\:lightgrey" cellpadding\=1 cellspacing\=1><tr align\=left><td nowrap class\=normal><b>
            的 style\="background-color\:lightgrey" 去除


10.员工录入前台验证，用的是jQuery的插件jquery-validate

5.对输入的登陆名进行ajax验证：验证该登录名在数据库中是否存在。

11.在loginname字段已经给出对应的“该登录名已经被占用”的基础上，再一次点击“提交”按钮，则需要进行服务器端验证，再返回录入页面

12.若验证都通过，则需要进行服务器端的验证。

13.员工的录入操作:
    1). 显示员工的录入页面
        ①. 查询数据库, 获取所有的部门信息和职位信息, 并在页面上加以显示
        ②. 页面使用 jQuery 的 validator 插件作为表单的前台验证
            1. 在当前 jsp 页面中导入 jquery.validate.js
            2. 为需要验证的字段添加 class 属性, 在其中指定验证规则, 获取添加 minlength 等属性

  今天就到此了！   

    

                             SVN版本控制

今天有毛伟老 师讲版本控制，版本控制（Revision control）是维护工程蓝图的标准做法，能追踪工程蓝图从诞生一直到定案的过程，确保由不同人员所编辑的同一文 件档案都能得以同步。最新的Spring3.0已经提供了更高级的版本控制，但是国内没几个用，先掌握SVN，以后有机会再用高级的。下面详细总结 一下:

1.Subversion介绍:是一种开放源码的全新版本控制系统。是新一代的版本控 制工具，他不但提供了常见的比较、修补、标记、提交、回复和分支等功能，适于 Web 开发和其他 在传统方式下未采纳版本控制功能的领域

2.svn安装

 1.运行svn的server端，运行setup.exe,就OK

 检验安装好了：

 运行dos窗口 ，输入svn ，回车，出现svn help 提示，安装成功

 2.svn服务器启动（我安装目录：D:"Program Files"Subversion"bin）

 cmd：

 svn根目录 svnserve -d 即D:"Program Files"Subversion"bin>svnserve –d

是否启动成功

.当前是否启动3690端口号

3.版本库目录介绍：

  dav目录:是提供给Apache与mod_dav_svn使用的目录，让它们存储内部数据，当前我们使用的版本没有这个目录（与你下载的Subversion版 本有关系）。

    db目录:就是所有版本控制的数据存放文件。

    hooks目录:放置hook脚本文件的目录。

    locks目录:用来放置Subversion文件库锁定数据的目录，用来追踪存取文件库的客户端。

    format文件是一个文本文 件，里面只放了一个整数，表示当前文件库配置的版本号。

    conf目录:是这个仓库的配置文件（仓库的用户访问帐号、权限等）。

4.创建版本库、导入、检出

1、创建版本库

       右键--->TortoiseSVN--->Create repository here

2.导入

       右键--->TortoiseSVN--->导入(一般在项目创建初始化数据时使用，当然也可用于把任意文件或目录从外部导入到指定仓库中)

3.检出（提醒：检出项目后客户端文件夹 的变化.svn）

      右键--->SVN Checkout...

5.SVN基本功能：

清理、更新到指定版本

日志记录、提交日志限定必填。

锁定、解锁：基本权限控制(可以限制被锁定的文件只能由被锁定用户修改提交)

误删除恢复操作:直接重更新或通过日志列表

单个文件过滤:选中文件-->TortoiseSVN---->增加到忽略列表

导出：使项目脱离版本控制。

6.总结SVN的使用：

在其文件夹上右键 "SVN Checkout..."写上对应SVN地址

 在其文件夹上右键 "SVN Update" 来更新我们的本地版本

在其文件夹上右键 "SVN Commit" 来提交我们的本地版本

 在其文件夹上右键 "TortoiseSVN" --> "Export..." 来 发布、导出

在其文件上右键 "TortoiseSVN" --> 增加(A)" 来向版本库中增加一 个受版本控制的文件

7.关于SVN的各种颜色提示说明：

CVS客户端的使用基本上同SVN客户端一样，更简单些，就不多说了

                         spring对事务的管理

   今天讲了Spring的事务，及对hibernate的整合，对struts的整合。以后还得学习，记不住，用到再整理。

1.事务的四大特点：

   atomic:要么都发生，要么都不发生。

   consistent:数据应该不被破坏。

   Isolated:用户间操作不相混淆

   Durable:永久保存

2.介绍spring的事务管理器

 spring没有直接管理事务，而是将管理事务的责任委

 托给某个特定平台的事务实现。

3.Hibernate事务：

       <bean id="transactionManager"

             class="…HibernateTransactionManager">

             <property name="sessionFactory" ref="sf" />

       </bean>

其中sessionFactory属性必须和一个Hibernate的SessionFactory绑定

   HibernateTransactionManager把事务管理委托给一个从Hibernate

       session 中取得的net….Transaction对象。当一个事务成功完成时，

       HibernateTransactionManager将调用Transaction对象的commit()

       方法。类似的，当一个事务失败时，Transaction对象的rollback()方

       法将被调用。

4.事务属性

   1.隔离级别：设定事务的并发程度

        脏读:一个事务读取了另一个事务改写但还未

               提交的数据，如果这些数据被回滚，则

               读到的数据是无效的。

        不可重复读:一个事务执行相同的查询两次或两次以

                      上，但每次查询结果都不同。

        幻读:一个事务读取了几行记录后，另一个事务插入一

               些记录，幻读就发生了。再后来的查询中，第一

               个事务就会发现有些原来没有的记录。

   2.只读               若对数据库只进行读操作，可设置事务只读的属性，使用某些优化措施。数据库会进行优化处理。若使用hibernate作为持久化机制，声明一个只读事务会使hibernate的flush模式设置为FLUSH_NEVER。避免不必要的数据同步，将所有更新延迟到事务的结束。

   3.事务超时 若事务在长时间的运行，会不必要的占用数据库资源。设置超时后，会在指定的时间片回滚。将那些具有可能启动新事务的传播行为的方法的事务设置超时才有意义

5.CMT:容器管理事务

   BMT：bean 管理事务

<tx:annocation-driven transaction-manager="hibernateTransactionManager"/>

类上加@Transactional

6.总结：

事务策略

在业务中不能加try catch ，因为Spring的环绕通知在出现异常时会回滚事务，你已捕获，就会提交事务（任何情况下）

7.Spring整合Struts

 1.web服务器启动时，完成Spring容器的实例化。plugin|listener

 2.struts中的action交给Spring容器管理。

 3.基本操作

 注意：在spring上下文中,作为普通bean配置action,但action的不能用id,只能用name,

因为需要struts-config.xml文件中action的path一致.

bean.xml

<bean name="/loginAction" class="..LoginAction">

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

</bean>

      今天主要是AOP编程，徐老师先讲了原理，由浅入深，最 后让开发由aspectJ来完成，使开发更简单，收获蛮大

1.Aspect术语

 通知：切面的实际实现，他通知系统新的行为。如在日志通知包含了实

      现日志功能的代码，如向日志文件写日志。通知在连接点插入 到应用系统中。

连接点：:应用程序执行过程中插入切面的地点，可以是 方法调用，异常抛出，或者      要修改的字段。

切入点：定义了通知应该应用在哪些连接点， 通知可以应用到AOP框架支持的任何         连接点。

          

引入：不变源代码的情况下，为类添加新方法 和属性。

目标对象：:被通知的对象。既可以是你编写的类也可以是 第三方类。

代理对象：崭新的对象，将通知应用到目标对 象后创建的对象，应用系统的其他部              分不用为了支持代理对象而 改变。

织入:将切面应用到目标对象从而创建一个新代理对 象的过程。织入发生在目标

              对象生命周期的多个点上：

               编译期：切面在目标对象编译时织入.这需要一个特殊的编译器.

               类装载期：切面在目标对象被载入JVM时织入.这需要一个特殊的类载入器.

               运行期：切面在应用系统运行时织入.

 4.切入点:定义了通知应该应用在哪些连接点，通知可以应用到AOP框架支持的任何连接点。

两种：jdk动态代理（接口，松耦合），cglib（对类代理）

2.方法介绍

 一.通知类型

 1.前置通知

   public interface MethodBeforeAdvice{

       void before(Method m,Object[]

                 os ,Object target){

        }

   }

   该接口提供了获得目标方法、参数和目标对象的机会。不能够改变运行时参数，即不能替换参数对象和目 标对象。

   注意在方法结束后不返回任何值东西。原因是该接口返回后，目标方法将会被调用，应该返回目标对象的 返回值。该接口唯一能

   阻止目标方法被调用的途径是抛出异常或(System.exit())。

 2.动态代理对象ProxyFactoryBean是一个在BeanFactory中显式创建代理对象的中心类，可以给它一个

 要实现的接口、一个要代理的目标对象、一个

 要织入的通知，并且他将创建一个崭新的代理

 对象。

 3.后置通知

    同前置通知类似。

        public interface AfterReturningAdvice{

             public void afterReturning(Object returnValue,Method

             m,Object[] os,Object target);

        }

   多了一个返回值。

 4.环绕通知

       public interface MethodInterceptor extends Interceptor{

           Object invoke(MethodInvocation invocation);

       }

       该接口同前两种通知有两个重要区别:1.该通知能够控制目标方法

       是否真的被调用。通过invocation.proceed()方法来调用。

       2.该通知可以控制返回的对象。可以返回一个与proceed()方法返回对象完全不同的对象。但要谨慎使用。

                                                         

 5.异常通知

        public interface ThrowsAdvice{

       }

       该接口为标识性接口，没有任何方法，但实现该接口的类必须要有如下形

       式的方法：

       void afterThrowing(Throwable throwable);

       void afterThrowing(Method m,Object[] os,Object

       target,Throwable throwable);

       第一个方法只接受一个参数：需要抛出的异常。

       第二个方法接受异常、被调用的方法、参数以及目标对象。

 二.创建切入点方法

        1. 切入点根据方法和类决定何处 织入通知。ClassFilter接口决定了一个类

        是否符合通知的要求：

        public interface ClassFilter{

             boolean matches(Class clazz);

        }

        实现该接口的类决定了以参数传递 进来的类是否应该被通知。实现该接

        口的类一般根据类名决定，但不一 定必须如此。

       注意： 为减少系统负担，尽量使用静态切入点

       

        2.定义切入点      spring提供了Advisor类。他把通知和切入点组合到一个对象中。更确切地说PointcutAdvisor提供了这些功 能

3.使用aspectJ开发

       1.添加类库:aspectjrt.jar和aspectjweaver.jar

       2.添加aop schema.

       3.定义xml元素:<aop:aspectj-autoproxy>

       4.编写java类,并用@Aspect注解成通知

            AspectJ 支持 5 种类型的通知注解:

        @Before: 前置通知, 在方法执行之前执行

        @After: 后置通知, 在方法执行之后执行

        @AfterRunning: 返 回通知, 在方法 返回结果之后执行

        @AfterThrowing: 异 常通知, 在方法 抛出异常之后

        @Around: 环绕通知, 围绕着方法执行

       配置成普通bean元素即可.

    注意：

    JoinPoint参数可访问连接点细节,入方法名和参数等.

今天知识点蛮多的，对面试挺有用的，好好掌 握！

    

                                      Spring

 对这个框架并不陌生，spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架.它的主要目得是简化企业开发...

1.为Spring添加jar支持

2.Spring：1.xml + 反射

       2.不需要实例化

          3.不需要set方法

 以前 至上而下， 按部就班

              之下而上，反的

3. bean的生命周期

       bean被载入到容器中时，他的生命周期就开始

       了。bean工厂在一个bean可以使用前完成很多

       工作：

       1.容器寻找bean的定义信息并实例化。

       2.使用依赖注入，spring按bean定义信息配置bean的所有属性。

       3.若bean实现了BeanNameAware接口，工厂调用Bean的setBeanName

        （）方法传递bean的ID。

       4.若bean实现了BeanFactoryAware接口，工厂调用setBeanFactory（）

          方法传入工厂自身。

       5.若BeanPostProcessor和bean关联，则它们的

          postProcessBeforeInitialization()方法被调用。

       6.若bean指定了ini-method方法、，它将被调用。

       7.最后，若有BeanPostProcessor和bean关联，则它们的

          postProcessAfterInitialization()方法被调用、。

4.set注入的缺点：

 无法清晰表达哪些属性是必须的，哪些是可选

    的，构造注入的优势是通过构造强制依赖关系，不可能实例化不

    完全的或无法使用的bean。

5.自动装配

   <bean id=" " class="" autowire="autowire 类型">

    有四种自动装配类型：

    1.byName:寻找和属性名相同的bean,若找不到，则装不上。

    2.byType:寻找和属性类型相同的bean,找不到,装不上,找到多个抛异常。

    3.constructor:查找和bean的构造参数一致的一个或

      多个bean，若找不到或找到多个，抛异常。按照参数的类型装配 

    4.autodetect: (3) 或者(2)方式选一个。不确定

       性的处理与(3)和(2)一致。

注意：

     spring2.5提供了<context:annotation-config />配置.

     该配置可激活在类中探测到的各种注解,@Required @Autowire @PostConstrct @PreDestroy @Resource @EJB @PersistenceContext @WebServiceRef等等,

     也可以选择为这些注解激活单独的后处理器.

6.属性的外部化

 分散配置

 将配置文件分成几个分散的配置文件。如数据源。

   <bean class="...PropertyPlaceholderConfigurer">

        <property name="locations">

             <list>

                  <value>jdbc.properties</value>

                  <value>securtiy.properties</value>

               </list>

          </property>

    </bean>

   当然在Spring2.5可以简化为

   <context:property-placehoder location>

7.AOP

有一些模块是每个系统都需要的，切面是系统 模块化的一个切面或领域。如日志记录。不改变源代码，还给类增加新的功能

 2.连接点:应用程序执行过程中，可以应用切面的地点，可以是方法调用，异常抛出，或者要修改的

               字段。

 3.通知:切面的实际实现，他通知系统新的行为。

 4.切入点:定义了通知应该应用在哪些连接点，通知可以应用到AOP框架支持的任何连接点。

 5.引入:为类添加新方法和属性。

 6.目标对象:被通知的对象。既可以是你编写的类也可以是第三方类。

 7.代理:将通知应用到目标对象后创建的对象，应用系统的其他部分不用为了支持代理对象而

            改变。

 8.织入:将切面应用到目标对象从而创建一个新代理对象的过程。织入发生在目标

            对象生命周期的多个点上：

            编译期：切面在目标对象编译时织入.这需要一个特殊的编译器.

            类装载期：切面在目标对象被载入JVM时织入.这需要一个特殊的类载入器.

            运行期：切面在应用系统运行时织入.

今天到此结束，明天继续！

UML

今天学习UML，uml是unified modeling language，是一种基于面向对象的可视化建模语言. 老徐讲了很多与开发有关的东西，很不错，还介绍了软件的发展等，开始整理下

1. UML 采用了一组形象化的图形(如类图)符号作为建模语言, 使用这些符号可以形象地描述系统的各个方面。oop:ooa(分析) + ood(设计)

2.软件的生命周期

瀑布模型：

需求分析(可行性分析：)

1.时间可行性

2.技术可行性

3.经济可行性

系统分析和设计(系分)

实现

测试

维护

角色分配：项目经理技术总监代码人员测试人员 db管理人员系统分析人员

project leader 系统架构师

3. 统一软件开发过程(Rational Unified Process,RUP): 一个通用的软件流程框架, 以架构为中心, 用例驱动的迭代化开发流程.

4.uml：图（图元）

UML 中一共有 10 种图:

类图**** 对象图 包图 组件图 部署图 用例图** 时序图*** 协作图 状态图 活动图*

5.用例图

是从软件需求分析到最终实现的第一步, 它是从客户的角度来描述系统功能.

用例图包含 3 个基本组件: 参与者(Actor), 用例(Use Case),关系

6.类图

类图是面向对象系统建模中最常用的图. 是定义其他图的基础.

类图主要是用来显示系统中的类, 接口以及它们之间的关系.

类图包含的主要元素有类, 接口和关系. 其中关系有关联关系, 泛化关系, 依赖关系和实现关系. 在类图中也可以包含注释和约束.

7.类之间的几种关系：实现依赖关联聚合组成

实现关系：在 UML 中, 实现关系用来表示类与接口之间的实现关系.

依赖关系：对于两个相对独立的系统，当一个系统负责构造另一个系统的实例，或者依赖另一个系统的服务时，这两个系统之间体现为依赖关系.

关联：对于两个相对独立的系统，当一个系统的实例与另一个系统的一些特定实例存在固定的对应关系时，这两个系统之间为关联关系。

聚合：聚合关联是一种特殊的关联. 它表示类间的关系是整体与部分的关系.

组合关系： 整件拥有部件的生命周期, 所以整件删除时, 部件一定会跟着删除. 而且, 多个整件不可以同时共享同一个部件。

8. 时序图

时序图用于描述对象之间的传递消息的时间顺序, 即用例中的行为顺序.

当执行一个用例时, 时序图中的每条消息对应了一个类操作或者引起转换的触发事件.

对象: 时序图中对象使用矩形表示, 并且对象名称下有下划线. 将对象置于时序图的顶部说明在交互开始时对象就已经存在了. 如果对象的位置不在顶部, 表示对象是在交互的过程中被创建的.

生命线:生命线是一条垂直的虚线. 表示时序图中的对象在一段生命周期内的存在. 每个对象底部中心的位置都带有生命线.

9. 活动图

在 UML 中, 活动图本质上就是流程图. 它用于描述系统的活动, 判定点和分支等.

10.临时 持久化 游离 删除

11.状态图

状态图: 通过建立对象的生存周期模型来描述对象随时间变化的动态行为.

状态: 用圆角矩形表示. 状态名称表示状态的名字, 通常用字符串表示. 一个状态的名称在状态图所在的上下文中应该是唯一的.

12.包图:

由包和包之间的关系组成. 包的图标就如同一个带标签的文件夹.

13.组件图

用来建立系统中各组件之间的关系, 各组件通过功能组织在一起.

14.部署图

用来帮助开发者了解软件中的各个组件驻留在什么硬件位置, 以及这些硬件之间的交互关系。

今天就讲了这些知识，挺琐碎的，关键是看懂就OK了！

    

                                    JPA第二天

   今天JPA的第二天，继续学习关联,还有分页，设置参数，单值检索等重点，下午是EJB的介绍，实现。这其中足见老师水平之高，经验太丰富了。好 ，作总结：

1. 多对一单向关联

2.一对多

@OneToMany(mappedBy=””) 忽略关联关系

mappedBy让对端忽略关系的变化，相当于HibernateSet集合中的inverse，缓存就不再负责set的

em.find(Order.class,1);默认迫左/延迟

3.一对一外键关联

 <many-to-one name=”addr” column=”aid” class=”Addr” unique=”true”/>

 <one-to-one name=”” column=”” property-ref=”addr”/>

JPA中的实现

@OneToOne[观察自动创建出来的表结构]

 class User{

    @OneToOne

    protected Addr addr;

 class Addr{

    @OneToOne(mappedBy=“addr", optional="false");

    protected User user;

 }

 mappedBy:控制权问题

 optional:false 表示没有用户的BillingInfo是不能单独存在的.

4.多对多

@ManyToMany

 @ManyToMany

 protected Set<Student> students;

 @ManyToMany(mappedBy=“students")

 protected Set<Teacher> teachers;

5.继承关系

 以Employee为例

                Employee{id name age}

HourEmployee(HE){rate}          SalaryEmployee(SE){salary}

映射继承关系树：整个继承关系树对应一张表

游离,临时，持久 详解：

1.位于一个session缓存中，总是被一个

      session关联。

   2.持久化对象和数据库记录相对应。

   3.清理缓存时，会根据对象属性变化，同步

      更新数据库。

   4.save把临时对象转变为持久化对象。

   5.load或find或get返回的对象总是持久化状态。

   6.find方法返回的list存放的都是持久化对象。

   7.update、save、SaveOrUpdate和Lock方法使游离对象装变

     为持久化对象。

6、分页:

 ("findCustomerByName");

 query.setParameter("name", "t,om");

 query.setMaxResults(10);

 query.setFirstResult(3); query = em.createNamedQuery

 List customers = query.getResultList();

7、设置参数:

 SELECT o FROM Order i WHERE i.orderNo = ?1

 query.setParameter(1, 100.00);

 SELECT o FROM Order i WHERE o.price = :price

 query.setParameter("price", 100.00);

8.单个实体检索

 query.getSingleResult();

9.

查询集合:

 WHERE c.orders IS EMPTY

 WHERE CONCAT(c.fname, c.lname) = 't,om'

 SELECT c.id, c.name FROM Customer c

10.多态查询

 SELECT c FROM Customer c WHERE c.name LIKE :name

11.分组

 SELECT o.customer, COUNT(o.id) FROM Order o

                                     GROUP BY o.customer

12.排序

 order by

13.子查询

 SELECT o FROM Order I WHERE o.customer IN

 (SELECT c FROM Customer c WHERE c.name LIKE ?1)

                                        EJB

1.ejb简介：enterprise java bean就是开发分布式组件的。in

ejb容器具有负载均衡 容 错 线程池 安全 高并发性等功 能。

EJB　＝ pojo +　＠　

spring：业务层 管理bean的，容器key-value.没有ejb的java ee

j2ee : 开发分布式企业级应用的规范（jsp servlet jpa ejb）

2.开发ＥＪＢ步骤：

1.下载安装jboss

2.配置环境变量：

 JBOSS_HOME    JBOSS安装目录

3.web服务器端口（${jboss_home}"server"default"deploy"jboss-web.deployer"server.xml）[22行]

4.启动。${jboss_home}"bin"run.bat

IDE中配置服务器：

 windows/首选项/myeclipse/servers/jboss/4.x/运行模式(非调式模式) + jdk1.5.

5.启动服务器,进入管理页面.http://localhost:8088/

 点击[JMX Console]超链接

 点击Jboss/service=JNDIView

 ok.

今天就OK了！

    JPA

   今天讲的是JPA规范，还是由经验丰富的徐老师讲的，JPA是一门解决了各个ORM“诸侯争霸”的局面。详细点就是

1.JPA概述

JPA(Java Persistence API)是Sun官方提出的Java持久化规范。它为Java开发人员提供了一种对象/关系映射工具来管理Java应用中的关系数据。JPA是在充分吸收了现有Hibernate（数据库平台无关）、TopLink等ORM框架的基础上发展而来的，达到平台无关性（持久化技术产品）。

　JPA是EJB的一部分。

2.jar包支持

 Hiberante核心包(8个文件)

hibernate-distribution-3.3.1.GA，加上mysql的驱动jar

3. JPA规范要求在类路径的META-INF目录下放置persistence.xml，文件的名称是固定的。

事务的特点：acid: atomic consistent  isolate durable

4.JPA编程建模

映射关系

                                           

 

代理主键：( 采用一种增长策略) @id

  定义id属性,相当于Hibernate中的OID.这两个注解必须显式指定,其他的映射是隐

  式(默认)的.

 

5.方法上注解优先，测试CRUD操作

em.persist(order);

  em.find(Order.class,new Long(1));

  em.remove(order);

  em.merge(order);

6.JPA语法严谨，语句：select p from Person p where p.name=’tom’ select要写

7.不想往数据库中存，就注解　　@Transient

8. @Lob

  @Basic(fetch=FetchType.LAZY)

  protected byte[] picture;

映射temporal(精确度)

  @Temporal(TemporalType.DATE)//该注解只能注util.Date和Canlendar.

  protected Date creationDate;

 

9.组成关系

Customer homeAddress comAddress

 

Address{

 

}

 在类上加@Embeddable 

10.ＪＰＡ关系　　重点　　　　　　　　　　　　　

JPA关系 ManyToOne/OneToMany

 

@ManyToOne/@OneToMany

Class Order{

  @ManyToOne

  Customer customer ;

Class Customer{

  @OneToMany(mappedBy=“”)

  Set<Order> orders = ..

}

注:如果集合不采用泛型的话,如何才知道集合与谁关联.

   @OneToMany(targetEntity=Order.class,mappedby=“customer”)

  

今天就到此了！