JavaWeb编程基础

OGNL表达式语句：

• OGNL(Object DGraph Navigation Language):是一种强大的表达式语言,能够自动导航对象的结构并访问和设置对象数据
• OGNL上下文相当于一个Map容器,在Map容器中可以保存任何类型的数据(对象、数组等)

• 基本格式,如：

  JavaBean对象User{id:int; name:String}
  

  • 访问属性的方式为：

    #user.name
    

ONGL表达式语言的特点：

• 支持对象方法的调用
• 支持井台方法的调用
• 支持变量的赋值
• 可以操作 集合数据

Struts2中的OGNL：

• 在Struts2中,OGNL上下文作用于Struts2中的ActionContext对象

• ActionContext中的对象：

  • 值栈(根)、application、session、request、parameters、attr

  • 获取application中的对象：

    #application.name或#application.['name']
    

  • 获取request中的对象：

    #request.name或#request.['name']
    

  • 获取session中的对象：

    #session.name或#session.['name']
    

  • 获取parameters中的对象：

    #parameters.name或#parameters.['name']
    

  • 获取attr中的对象：

    #attr.name或#attr.['name']
    

• 在JSP页面中获取对象的属性：

  <s:property value="user.id" />
  或
  <s:property value="user[id]" />
  

  • 注意：Struts2的JSP页面需要导入标签库：

    <%@taglib prefix="s" uri="/struts-tags"%>
    

• 静态属性的调用方法如下：

  //通过@符号来标注
  @com.michale.djh.Bean@NAME
  

  • 注意：默认情况下,struts2不允许调用静态方法,需要在struts.xml文件中手动开启

    <constant name="struts.ognl.allowStaticMethodAccess" value="true" />
    

• 访问集合：

  • List集合：(有序集合),可以使用下标的方式访问,如：list[0]
  • Set集合：(无序集合),不能通过下标的形式访问

  • Map集合：键值对形式,通过key访问value:

    map.key 或 map.['key']
    

  • 获取所有的Key和value:

    map.keys //获取所有的Key
    map.values //获取所有的value
    

• 集合的操作：

  collection.isEmpty//判断集合元素是否为空
  colloection.size()//获取集合的长度
  

• 投影与选择：

  • 投影：对集合中列的操作,指将集合中的某一列数据都抽取出来形成一个集合,如：

    #list.{name} //获取一个包含多个学生对象集合的所有学生姓名
    

  • 选择：对集合中行的操作,指通过一定的条件获取集合中满足这一条件的的数据,所获取的行就是对集合中数据的选择操作,如：

    #list.{?#this.age>10}//获取所有年龄大于10的所有学生,"?"表示满足这一条件的所有对象
    

• OGNL表达式中的操作符：
  
  • ?：获取满足指定条件的所有元素
  • ^：获取满足指定条件的所有元素中的第一个元素
  • $：获取满足指定条件的所有元素中的最后一个元素

Struts2的标签库

• 数据标签：

  • property：用于获取数据值,并将数据值直接输出到页面中，其属性如下：
    
    • default：可选
    • escape：可选
    • escapeJavaScript：可选
    • value：可选

  • set：用于定义一个变量,可以为所定义的变量赋值及设置变量的作用域(application、request、session),set标签属性：

    • scope(String)：可选,设置变量的作用域，其默认值是action
    • value(String)：可选,设置变量的值
    • var(String)：可选,定义变量的名称

    • set标签用法：

      <s:set var="username" value="test set tag" scope="request"></s:set>
      <s:set default="no data!" value="#request.username"/>
      

  • a：用于构建超链接,常用属性：
    
    • action(String)：将超链接的地址指向action
    • href(String)：超链接地址
    • id(String)：设置HTML中的属性名称
    • method(String)：如果超链接的地址指向action,method同时可以为action声明所调用的方法
    • namespace(String)：可以为action声明命名空间
  • param：用于对参数赋值,属性如下：
    
    • name(String)：设置参数名称
    • value(Object)：设置参数值
  • action：用于执行 一个Action请求,可以将Action的返回结果输出到当前页面中,也可以不输出,其属性如下：
    
    • executeResult(String)：是否使Action返回到执行结果,默认值为false
    • flush(Boolean)：输出结果是否刷新,默认值为true
    • ignoreContextParams(Boolean)：是否将页面请求参数传入被调用的Action,默认值为false
    • name(String)：Action对象所映射的名称,也即是struts.xml中配置的名称
    • namespace(String)：指定名称空间的名称
    • var(String)：引用此action的名称

  • push：用于将对象或值压入到值栈中并放置到顶部,简化操作,用法如下：

    <s:push value="#request.student"></s:push>
    

  • date：用于格式化日期时间,可以对日期时间值进行指定的格式化样式格式化,包含的属性如下：
    
    • format(String)：设置格式化日期的样式
    • name(String)：日期值
    • var(String)：格式化时间的名称变量,通过该变量可以对其进行引用

  • include：类似于JSP的include标签,添加了可以在目标页面中通过param标签传递请求参数的功能,用法如下：

    <%@include file="/pages/common/admin.jsp"%>
    

  • url

• 控制标签：

  • if:

    • :可以单独使用
    • :配合使用
    • :配合使用

    • 使用方式：

      <s:if test="表达式(布尔值)">  //test属性用于设置标签的判断条件,其值为布尔类型的条件表达式,如：
      expression1
      <s:if>
      <s:elseif test="expr(Boolean)">
      expression2
      </s:elseif>
          ...
      <s:else>
      expression3
      </s:else>
      

  • iterator：可以遍历数组和集合类中的所有或部分数据(可以指定迭代数据的起始位置、步长以及终止位置来迭代集合或数组中的部分数据),其属性如下：
    
    • begin(Integer)：指定迭代数组或集合的起始位置,默认值为0
    • end(Integer)：指定迭代数组或集合的结束位置,默认值为集合或数组的长度
    • status(String)：迭代过程中的状态
    • step(Integer)：迭代的步长,默认值为1
    • value(String)：指定迭代的集合或数组对象
    • var(String)：设置迭代元素的变量,若指定此属性,那么迭代的变量将压入到值栈中

数据的验证机制：

• 手动验证的实现： 在继承ActionSupport类的情况下,重写validate()方法,在该方法中进行验证
• 验证文件的命名规则： 验证文件的名称必须是以下两种：(ActionName是Action对象的名称,AliasName为Action配置中的名称,也即是struts.xml配置文件中Action元素对应name属性的名称)
• ActionName-validation.xml: 数据的验证会作用于整个Action对象中,并验证Action对象的请求业务处理方法，适用于验证处理的规则都相同的形式
• ActionName-AliasName-validation.xml： 更加灵活。

• 验证文件的编写风格：

  • 字段验证器编写格式： 如：验证用户名与密码(注意xml文件需要指定编码格式),其中name为需要检验的字段

    <validators>
        <field name="username">
        <field-validator type="requiresstring">
            <message>Please Input user name</message>
        </field-validator>
        </field>
        <field name="password">
            <field-validator type="requiresstring">
            <message>Please Input password</message>
            </field-validator>
        </field> 
    </validators>
    

  • 非字段验证器编写格式： 如：用户名与密码验证

    <validators>
        <validator type="requiredstring">
            <param name="fieldName">password<param>
            <param name="fieldName">username<param>
            <message>Please Input text</message>
        </validator>
    </validators>
    

    • 使用param标签传递字段参数,其参数的名称为fieldName,参数的内容为字段的名称
  • 对于字段验证时,通常使用字段验证器编写格式

• 案例：

  • index.jsp:

    <body> 
        <h2>User Register</h2>
        <s:form action="userAction" method="post">
            <s:textfield name="name" label="user_name" required="true" requiredPosition="left"></s:textfield>   <!-- label标签用于定义页面显示的字段名 -->
            <s:password name="password" label="pass_word" required="true" requiredPosition="left"></s:password>
            <s:radio name="sex" list="#{1:'male', 0:'female' }" label="sex" required="true" requiredPosition="left"></s:radio>
            <s:select list="{'Please select province', 'JiLin', 'GuangDong', 'ShanDong', 'JiangXi'}" name="province" label="Province"></s:select>
            <s:checkboxlist list="{'football','basketball', 'table tennis'}" name="hobby" label="interest"></s:checkboxlist>
            <s:textarea name="description" cols="30" rows="5" label="desc"></s:textarea>
            <s:submit value="Register"></s:submit>
            <s:set value="Reset"></s:set>
        </s:form>
    </body>
    

  • struts.xml:

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
    "http://struts.apache.org/dtds/struts-2.3.dtd">
    <struts> 
        <constant name="struts.devMode" value="true" />
        <package name="default" namespace="/" extends="struts-default">
            <action name="userAction" class="com.michael.djh.demo1.UserAction">
                <result>success.jsp</result>
            </action> 
        </package>
    </struts>
    

  • UserAction.java:

    public class UserAction extends ActionSupport {
        private static final long serialVersionUID = 1L;
        private String name;
        private String password;
        private String description;
        private int sex=0;
        private String province;
        private String[] hobby;
    
        @Override
        public String execute() throws Exception {
            // TODO Auto-generated method stub
            return SUCCESS;
        }
    
        //Getter and Setter method
        ......
    }
    

• 默认情况下,Struts2的验证框架验证失败后会返回input对应的页面

struts2的配置文件：

• struts.xml:

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE struts PUBLIC
  "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
  "http://struts.apache.org/dtds/struts-2.3.dtd">
  <struts> 
      <constant name="struts.devMode" value="true" />
      <package name="default" namespace="/" extends="struts-default">
          <action name="userAction" class="com.michael.djh.demo1.UserAction">
              <result>success.jsp</result>
          </action> 
          <action name="login" class="com.michael.djh.demo1.LoginAction">
              <result name="input">login.jsp</result>
              <result>success.jsp</result>
          </action>        
      </package>
  </struts> 
  

• web.xml:

  <?xml version="1.0" encoding="UTF-8"?>
  <web-app id="WebApp_9" version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
      <display-name>Struts 2 Rest Example</display-name>
      <welcome-file-list>
      <welcome-file>login.jsp</welcome-file>
      </welcome-file-list>
      <filter>
          <filter-name>struts2</filter-name>
          <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>
      </filter>
      <filter-mapping>
          <filter-name>struts2</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
  </web-app> 
  

Hibernate：

• Hibernate通过持久化类(.java)、映射文件(.hbm.xml)与配置文件(*.cfg.xml)操作关系型数据库
• Hibernate三大类：
  
  • 配置类(Configuration)： 负责管理Hibernate的配置信息以及启动Hibernate,包含数据库URL、数据库用户名、数据库用户密码、数据库驱动类及数据库适配器(dialect)
  • 会话工厂类(SessionFactory)： 用于声称Session的工厂,保存了当前数据库中所有的映射关系,是[线程安全]的,为一个重量级对象,初始化创建过程会耗费大量的系统资源
  • 会话类(Session)： 数据库持久化操作的核心,负责Hibernate所有的持久化操作,可以实现数据库的CRUD操作,但会话类并不是线程安全的,应避免多个线程共享一个Session

• Hibernate通过读取默认的XML配置文件hibernate.cfg.xml加载数据库的配置信息,该配置文件被默认放于项目的classpath根目录下,如：

  //连接应用的MySQL数据库
  <?xml version="1.0" encoding="utf-8"?>
  <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
  <hibernate-configuration>
      <session-factory>
          <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
          <property name="connection.username">root</property>
          <property name="connection.password">java</property>
          <property name="dialect">org.hibernate.dialect.MySQLDialect</property>  //Hibernate方言
          <property name="show_sql">true</property>
          <mapping resource="com/michael/djh/employee/Employee.hbm.xml" />    //打印SQL语句
          <mapping resource="com/michael/djh/user/User.hbm.xml" />    //映射文件
      </session-factory>
  </hibernate-configuration>
  

  • property元素的常用配置属性：
    
    • connection.driver_class：连接数据库的驱动
    • connection.url：连接数据库的URL地址
    • connection.username：连接数据库用户名
    • connection.password：连接数据库密码
    • dialect：设置连接数据库使用的方言
    • show_sql：是否在控制台打印SQL语句
    • format_sql：是否格式化SQL语句
    • hbm2ddl.auto：是否自动生成数据库表
• Hibernate中的持久化类编成规则：
  
  • 实现一个默认的构造函数: 所有的持久化类中都必须含有一个默认的无参数构造方法，通过Constructor.newInstance()实例化持久类
  • 提供一个标识属性(option): 一般用于映射数据库表中的主键字段
  • 使用非final类(option): 使用final类,Hibernate就不能使用代理来延迟关联加载,会影响开发人员进行性能优化的选择
  • 为属性声明访问器(option): 持久化类的属性不能声明为public的,最好以private的set()和get()方法对属性进行持久化

• Hibernate映射：

  • 映射文件的命名规则为：*.hbm.xml,如(User对象配置)：

    <?xml version="1.0" encoding="utf-8"?>
    <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping>
        <class name="com.michael.djh.User" table="tb_user">
            <id name="id" column="id" type="int">//持久化类的唯一标识
                <generator class="native" />
            </id>
            <property name="name" type="string" not-null="true" length="50">
                <column name="name" />
            </property>
            <property name="password" type="string" not-null="true" length="50">
                <column name="password" />
            </property>
        </class>
    </hibernate-mapping>
    

  • 元素包含一些可选的属性：
    
    • schema：指该文件映射表所在数据库的schema名称
    • package：指定一个包前缀
  • 元素用于指定持久化类和映射的数据库名,name属性需要指定持久化类的全限定的类名,table属性就是持久化类所映射的数据库表名
  • 元素用于持久化类的其他属性和数据表中非主键字段的映射,其属性有以下几个：
  • name：持久化类属性的名称,以小写字母开头
  • column：数据库字段名
  • type：数据库的字段类型
  • length：数据库字段定义的长度
  • not-null：该数据库字段是否可以为空,属性值为布尔变量
  • unique：该数据库字段是否唯一
  • lazy：是否延迟抓取

• Hibernate数据持久化：

  • Hibernate的实例三种状态：
    
    • 瞬时状态(Transient)
    • 持久化状态(Persistent)
    • 脱管状态(Detached)

  • Hibernate工具类,避免Session的多线程共享数据问题, SessionFactory的获取：

    Configuration configuration = new Configuration.configure();
    SessionFactory factory = configuration.buildSessionFactory();
    

    • Configuration对象会自动加载Hibernate的基本配置信息,如果没有在configure()方法中指定加载配置XML文档的路径信息,Configuration对象会默认加载项目classpath下的hibernate.cfg.xml文件

    • HibernateUtil.java:(用于初始化Hibernate)

      public class HibernateUtil{
          private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
          private static SessionFactory sessionFactory = null;
          static{
              try{
                  Configuration configuration = new Configuration.configure();
                  sessionFactory = configuration.buildSessionFactory();
              }cathc(Exception e){
                  e.printStackTrace();
              }
          }
          //get Session
          public static Session getSession() throws HibernateException(){
              Session session = (Session)threadLocal.get();
              if(session == null || !session.isOpen()){
                  if(sessionFactory == null){
                      rebuildSessionFactory();
                  }
                  session = (sessionFactory != null) ? sessionFactory.openSession : null;
                  threadLocal.set(session);
              }
              return session;
          }
          public static void rebuildSessionFactory(){
              try{
                  Configuration configuration = new Configuration.configure();
                  sessionFactory = configuration.buildSessionFactory();
                  }cathc(Exception e){
                  e.printStackTrace();
              }
          }
          //get SessionFactory
          public static SessionFactory getSessionFactory(){
              return sessionFactory;
          }
          //close Session
          public static void closeSession() throws HibernateException{
              Session session = (Session)threadLocal.get();
              threadLocal.set(null);
              if(session != null){
              session.close();
              }
          }
      }
      

  • 数据保存：

    • 数据的持久化过程：

      application->Configuration->SessionFactory->Session->数据操作->正常commit,失败rollback->close()
      

    • 开启事务：

      session.beginTransaction();
      

    • 执行数据库添加操作：

      session.save(user);
      

    • 事务提交：

      session.getTransaction().commit();
      

    • 事务回滚：

      session.getTransaction().rollback();
      

    • 注意：最后需要关闭session.

  • 查询数据：Session对象提供了两种对象装载的方法，即get()与load()方法

    • get()方法：装载对象后会立刻访问数据库，适用于不确定数据库中是否有匹配的记录存在时用
    • load()方法：返回对象的代理,只有在返回对象被调用时,Hibernate才会发出SQL语句去查询对象

    • 如：

      User user = (User)session.get(User.class, new Integer("1"));
      String name = user.getName();
      String sex = user.getSex();
      ...
      

  • 删除数据：delete()方法, 只有对象在持久化状态时才能执行delete()方法

• 延迟加载： load方法或者设置property元素的lazy属性,如：

  <hibernate-mapping>
      <class name="com.michael.djh.User" table="tb_user">
          <id name="id" column="id" type="int">
              <generator class="native" />
          </id>
          <property name="name" type="string" length="15" lazy="true">
              <column name="name" />
          </property>
      </class>
  </hibernate-mapping>
  

  • 通过上述方式的设置,用户的姓名属性就被设置成了延迟加载

• Hibernate缓存：

  • 缓存分类：
    
    • 一级缓存(Session level)：也称为内部缓存,生命周期与Session相同
    • 二级缓存(SessionFactory level)：用于数据更新频率低,系统频繁使用的非关键数据,以防止用户频繁访问数据库,过度消耗资源
    • 在Hibernate中不同的Session之间是不能共享一级缓存的,也即是一个Session不能访问其他Session在一级缓存中的对象缓存实例

  • 利用EHCache作为Hibernate的二级缓存的配置，如：(查询产品信息)

    • hibernate.cfg.xml:

      <hibernate-configuration>
          <session-factory>
              ...
              <property name="hibernate.cache.use_second_level_cache">true</property>//开启二级缓存
              <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
          </session-factory>
      </hibernate-configuration>
      

    • 在持久化类的映射中需要指定缓存的同步策略,关键代码如下：

      <hibernate-mapping>
          <class name="com.michael.djh.Product" table="tb_product">
              <cache usage="read-only" /> //指定的缓存的同步策略
              ...
          </class>
      </hibernate-mapping>
      

    • 缓存的配置文件放在classpath目录下ehcache.xml(在Hibernate的zip包下的etc目录中可查看到),代码如下：

      <ehcache>
          <diskStore path="java.io.tmpdir" />
          <defaultCache
              maxElementsInMemory="10000"
              eternal="false"
              timeToIdleSeconds="120"
              timeToLiveSeconds="120"
              OverflowToDisk="true"
          />
      </ehcache>
      

• 实体关联关系映射：

  • 多对一单向关联：

    • product与factory表：

      tb_product{id, name, price, factoryid}
      tb_factory{factoryid, name}
      

    • 在产品对象的映射文件中建立多对一的关联,代码如下：(Product类引用Factory类)

      <hibernate-mapping>
          <class name="com.michael.djh.Product" table="tb_product">
              <id name="id" column="id" type="int">   //id 值
              <generator class="native" />
          </id>
          <property name="name" type="string" length="45">    //product name
              <column name="name" />
          </property>
          <property name="price" type="double">   //product price
              <column name="price" />
          </property>
          <many-to-one name="factory" class="com.michael.djh.Factory">    //多对一关联映射
              <column name="factoryid" /> //映射字段
          </many-to-one>
          </class>
      </hibernate-mapping>
      

    • 单向多对一关联时,只能通过主控方对被动方进行级联更新

  • 多对一双向关联：

    • Product与Factory类：

      Product{int:id, String:name, double:price, Factory:factory}
      Factory{int:factoryid, String:factoryName, Set:products}
      

    • 映射代码：

      <hibernate-mapping>
          <class name="com.michael.djh.Factory" table="tb_factory">
              <id name="factoryid" column="factoryid" type="int"> //id 值
                  <generator class="native" />
              </id>
              <property name="factoryName" type="string" length="45"> //product name
                  <column name="factoryname" />
              </property>
              <property name="price" type="double">   //product price
                  <column name="price" />
              </property>
              <set name="products" inverse="true">    //定义一多映射
                  <key column="factoryid" />
                  <one-to-many class="com.michael.djh.Product" />
              </set>
          </class>
      </hibernate-mapping>
      

• 级联操作：

  • 指的是当主控方执行save、update、delete操作时，关联对象(被控方)是否进行同步操作,可以通过cascade属性来设置,其属性值如下：
    
    • all：所有情况下均采用级联操作
    • none：默认的参数,所有情况下均不采用级联操作
    • save-update：在执行save-update方法时执行级联操作
    • delete：在执行delete方法时执行级联操作

  • 映射文件的配置,如：

    <hibernate-mapping>
        <class name="com.michael.djh.User" table="tb_user">
            ...
            <one-to-one name="com.michael.djh.IDCrad" cascade="all">
        </class>
    </hibernate-mapping>
    

• HQL(Hibernate Query Language)：Hibernate查询语言

  • 完全面向对象的查询语言,提供了更加面向对象的封装,返回的是匹配的单个实体对象或多个实体对象的集合
  • HQL语句区分大小写(由于查询的是对象,对象是Java类,而Java大小写敏感)

  • HQL的基本语法：

    select "对象.属性名"
    from "对象"
    where "过滤条件"
    group by "对象.属性名" having "分组条件"
    order by "对象.属性名"
    

    • 如：

      select * from Employee emp where emp.flag='1'
      等价于
      from Employee emp where emp.flag='1'
      

• 通过from子句查询指定字段数据，如：

  select Person(id, name) from Person per
  

• 如：查询Employee对象的所有信息

  List employees = new ArrayList();
  Session session = null;
  session = HibernateUtil.getSession();
  String hql = "from Employee employee";
  Query  query = session.createQuery(hql); 
  employees = query.list();
  HibernateUtil.closeSession();
  

• HQL参数邦定机制：

  • 参数邦定机制可以使查询语句和参数具体值相互独立，不但可以提高程序的开发效率，还可以有效地防止SQL的注入攻击

  • HQL提供动态赋值的两种实现方式：

    • 利用顺序占位符”?”替代具体参数,如：(类似于JDBC中的PreparedStatement对象的操作方式)

      //查询性别为"male"的员工信息
      session = HibernateUtil.getSession();
      String hql = "from Employee employee where employee.sex=?";
      Query query = session.createQuery(hql);
      query.setParameter(0, "male");
      employees = query.list();
      

    • 利用引用占位符”:parameter”替代具体参数,引用占位符是”:”与自定义参数名的组合,如：

      session = HibernateUtil.getSession();
      String hql = "from Employee employee where employee.sex=:sex";
      Query query = session.createQuery(hql);
      query.setParameter("sex", "male");
      employees = query.list();
      

• 排序查询：使用的是对象的属性,如：

  //以年龄从小到大排序
  from Employee employee order by employee.age desc
  

• 聚合函数,类似于SQL,如：

  select avg(employee.age) from Employee employee
  

Spring框架：

• 由七大核心模块组成:
  
  • Core：支持工具类,bean容器,实现了IoC模式,包含重要的BeanFactory类
  • Context：继承BeanFactory类,Context验证、JNDI、EJB、E-mail等
  • AOP：元数据及动态代理实现
  • DAO：事务基础设施、JDBC、DAO,简化数据库厂商的异常错误
  • ORM：支持Hibernate、iBatis与JDO
  • WEB：建立在Context之上,提供了Servlet监听器的Context和Web应用的上下文
  • MVC：Web MVC框架、Web视图,实现控制逻辑和业务逻辑清晰的分离

• Spring内置了日志组建log4j.jar,所以在使用Spring之前需要对log4j进行简单的配置,即在src根目录下创建log4j.properties 属性文件,代码如下：

  #输出级别,输出错误信息,输出源为标准出源stdout
  log4j.rootLogger=WARN.stdout
  #将stdout输出到控制台
  log4j.appender.stdout=org.apache.log4j.ConsoleAppender
  #日志输出的布局类
  log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
  #指定日志输出内容的格式
  log4j.appender.stdout.layout.ConversionPattern=%d %p [%c]-%m %n
  

• 使用BeanFactory管理bean

  • BeanFactory通过从XML配置文件或属性文件中读取JavaBean的定义,来实现JavaBean的创建、配置和管理,其中XmlBeanFactory可以通过流行的XML文件格式读取配置信息来装载JavaBean,如：

    Resource resource = new ClassResource("applicationContext.xml");
    BeanFactory factory =  new XmlBeanFactory(resource);
    Test test = (Test)factory.getBean("test");
    

  • applicationContext.xml:

    <?xml version="1.0" encoding="utf-8" ?>
    <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
    <beans>
        <bean id="test" class="com.michael.test.Test" />
    </beans>
    

  • Spring中bean的生命周期：

    实例化JavaBean、初始化JavaBean、使用JavaBean、销毁JavaBean
    

• 依赖注入：IoC(Inversion of Control)：控制反转，依赖注入

  • 依赖注入的三种实现类型(Spring支持后两种)：

    • 接口注

    • Setter注入,如：

      package com.michael.djh.User;
      public class User{
          private String name;
          private Integer age;
          //Getter与Setter方法
          ...
      }
      
      则Spring的配置文件applicationContext.xml为：
      <bean name="user" class="com.michael.djh.User">
          <property name="name">
              <value>Michael</value>
          </property>
          <property name="age">
              <value>20</value>
          </property>
      </bean>
      
      主程序如下即可获取bean对象：
      Resource resource = new ClassPathResource("applicationContext.xml");    //load configuration file
      BeanFactory factory = new XmlBeanFactory(resource);
      User user = (User)factory.getBean("user");  //user.getName()、user.getAge()即可得到值
      

    • 构造器注入
• Spring中的自动装配方式：
  
  • no属性：这是autowire采用的默认值,必须使用ref直接引用其他的bean
  • constructor属性：通过构造方法的参数类型自动装配
  • autodetect属性：会优先使用constructor方式来自动装配,然后使用byType方式

• Srping 设置singleton模式的三种方式：(对bean请求方式类似于静态的getInstance()方法)

  <bean id="test" class="com.michael.Test" /> //默认的即为singleton作用域
  <bean id="test" class="com.michael.Test" singleton="true"/>
  <bean id="test" class="com.michael.Test" scopr="singleton"/>
  

• Spring IoC设置prototype的两种方式：(对bean的请求类似于new对象,每次都会重新创建一个新的)

  <bean id="user" class="com.michale.User" singleton="false" />   //设置singleton的值为false
  <bean id="user" class="com.michael.User" scope="prototype" />
  

• Spring AOP:(面向切面编程)

  • 切入点：依据切入点织入的位置不同，提供了以下三种类型的切入点：
    
    • 静态切入点
    • 动态切入点
    • 其他切入点

  • 静态切入点：需要在配置文件时指定,关键配置如下：

    <bean id="pointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">
        <property name="advice">
            <ref bean="MyAdvisor" />    //指定通知
        </property>
        <property name="patterns">
            <list>
                <value>.*getConn*.</value>  //指定所有以getConn开头的方法名都是切入点
                <value>.*closeConn*.</value>
            </list>
        </property>
    <bean>
    

  • 静态切入点只能应用在相对不变的位置,而动态切入点应用在相对变化的位置

• Spring的DAO理念：

  • Spring DAO抽象提供了以下几种类：
    
    • JdbcDaoSupport：需要设置数据源,通过子类,能够获得JdbcTemplate来访问数据库
    • HibernateDaoSupport：需要设置Hibernate SessionFactory,通过子类能够获得Hibernate实现

  • Spring的配置文件applicationContext.xml的具体配置如下(以User类为例)：

    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName">
            <value>com.mysql.jdbc.Driver</value>
        </property>
        <property name="url">
            <value>jdbc:mysql://localhost:3306/db_michael</value>
        </property>
        <property name="username">
            <value>root</value>
        </property>
        <property name="password">
            <value>michael</value>
        </property> 
    </bean>
    
    <!-- 为UserDAO注入数据 -->
    <bean id="userDAO" class="com.michael.dao.UserDAO">
        <property name="dataSource">
            <ref local="dataSource" />
        </property> 
    </bean>
    

• 事务应用管理：

  • 编程式事务管理(两种实现方法：PlatformTransactionManager与TransactionTemplate(优先采用该方法)),配置文件如下：

    <!-- 定义 TransactionTemplate模板 -->
    <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
        <property name="transactionManager">
            <ref bean="transactionManager" />
        </property>
        <property name="propagationBehaviorName">
            <value>PROPAGATION_REQUIRED</value>
        </property> 
    </bean>
    <!-- 定义事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.DataSourceTransactionTemplate">
        <property name="dataSource">
            <ref bean="dataSource" />
        </property> 
    </bean>
    

  • 声明式事务管理

JSP操作XML：(使用dom4j)

• 创建XML文档对象:

  Document document = DocumentHelper.createDocument();
  或者
  Document document = DocumentFactory.getInstance().createDocument();