首先说明一下，本人目前主要从事.NET领域的工作，但对于C++、Java、OC等语言也略知一二，周末闲来无事，特花费一天的时间学习了一下Java中的SSH框架，希望把学习过程中的心得体会与园友们进行分享，共勉之。

SSH框架主要是指Struts、Spring、Hibernate，其中Struts主要擅长Java EE开发中的MVC模式，其优点主要体现的视图和控制器的解耦上，Spring主要擅长于IOC（依赖注入）和AOP（面向切面的编程），主要是为了解决企业应用程序维护的复杂性问题成创立的，Hibernate是一个非常出色的ORM框架，拥有强大的一级二级缓存机制结合数据库连接池（POOL），大大提高CURD的操作效果，项目加入了Hibernate以后，还可以更好地进行面向对象的编程。

    一、Struts

首先介绍Struts，在Web项目中加入Struts的jar包，并在Web.xml中添加 Struts的配置：

<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>

其中filter是指对用户请求的拦截，url-pattern中的/*是指使用Struts对所有的请求进行拦截。接着创建一个Login.jsp，源码如下：

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%@ page isELIgnored="false" %>
<%@ taglib uri="/struts-tags" prefix="s"%>  

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <title>用户登录</title>

    <meta http-equiv="pragma" content="no-cache">
    <meta http-equiv="cache-control" content="no-cache">
    <meta http-equiv="expires" content="0">
  </head>

  <body>
      <s:form action="Login.action" method="post">
        <s:textfield name="UserName" label="帐号">
          </s:textfield>

          <s:password name="Password" label ="密码">
          </s:password>
          <s:submit value="登录"></s:submit>
      </s:form>
 </body>
</html>

其中的【s:】的的标签是由Struts的标签库提供的，Struts中提供了一个非常强大的标签库，利用这些标签库可以辅助开发者进行HTML的表单设计和一些业务逻辑控制，form标签中的action指向的是我们的控制器，默认是以.action结尾，我们添加一个控制器类，用于处理用户的登录请求，命名为Login.java,源码如下：

package account;

import com.opensymphony.xwork2.Action;
import com.opensymphony.xwork2.ActionSupport;

public class Login extends ActionSupport {
    public String UserName;
    public String Password;
    public String getUserName() {
        return UserName;
    }
    public void setUserName(String userName) {
        UserName = userName;
    }
    public String getPassword() {
        return Password;
    }
    public void setPassword(String password) {
        Password = password;
    }

    //对表单进行验证
    @Override
    public void validate() {
        if(UserName.equals(""))
        {
            this.addFieldError("UserName", "用户名不允许为空！");
        }
        if(Password.equals("")){
            this.addFieldError("Password", "密码不能为空！");
        }
    };
    //执行控制器逻辑
    public String execute()
    {
        if(UserName.equals("admin") && Password.equals("123")){
            return Action.SUCCESS;
        }
        else {
            return Action.ERROR;
        }
    }
}

其中Login的类继承自ActionSupport，ActionSupport类实现了Struts的Action的接口，并且还具有了对表单进行验证的功能，在Login中重写alidate就可以对表单进行验证，在出错的时候，添加错误信息。execute相当于控制器的“main”函数，其必须为public类型，并且返回值为String，在本例中返回的结果为Action中的5个字符常量之一（当然，也可以自定义返回接口）。

接下来在src的目录下对struts.xml添加相应的配置，把控制器和我们的jsp文件关联起来，配置的代码如下：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN" "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
<package name="ghyStruts" extends="struts-default">
<action name="Login" class="account.Login">
    <result name="success" type="redirectAction">
    <param name="username">${UserName}</param>
    <param name="actionName">index</param>
    </result>
    <result name="error">/error.jsp</result>
    <result name="input">Login.jsp</result>
</action>

<action name="index" class="home.index">
    <result name="index">/index.jsp</result>
</action>
</package>
</struts>

其中的action代表了一个控制器请求，result是指请求返回的结果（控制器类中的execute方法的返回值），其中的name与返回的字符串必须要对应起来，type="redirectAction"代表跳转到另外一个action中，还可以在跳转的时候，添加参数，参数的名称、值和跳转结果的action的名字都是由param指定。如果需要直接返回到另外一个jsp页面，可以直接在result中添加jsp的名字，如/error.jsp，其中的“/”代表根目录。

Struts中提供了大量的标签库，标签库中的所有的标签头都是以s开头，格式为s:xxx，以其中的控制标签if为例：

<s:if test="UserName=='admin'">您好，管理员！</s:if>
<s:else>您好，普通用户！</s:else>

其中test是判断条件，UserName为控制器返回的属性，里面的内容是条件为真时的结果。

二、Spring

下面来介绍一些Spring框架实现的IoC，首先添加一个接口IService，代码如下：

package lizon;

public interface IService {
    public void save();
}

再添加一个Service类实现该接口：

package service;

import lizon.IService;

public class Service implements IService {
    public void save() {
        System.out.println("保存");
    }
}

添加一个Run，来调用接口的save：

package lizon;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import service.Service;

public class Run {
    private IService isvc;
    public IService getIsvc() {
        return isvc;
    }
    public void setIsvc(IService isvc) {
        this.isvc = isvc;
    }
    public static void main(String[] args) {

    }
}

注意，我们的Run类中有一个IService接口的属性，接下来，我们通过Spring的配置，把Service注入到IService中：

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <bean id="svc" class="service.Service">
    </bean>

    <bean id="run" class="lizon.Run">
        <property name="isvc" ref="svc"></property>
    </bean>
</beans>

首先配置一个Service的bean，并给它的实例起个名字叫svc，然后配置一个run的bean，并把svc的实现，注入到Run类中的IService接口中。这样在Run的main方法中，我们就可以这样调用：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Run run = (Run) context.getBean("run");
run.isvc.save();

通过ApplicationContext来获得配置文件中的接口的实现，然后进行调用。在我们的Run方法中没有涉及到任何实现的代码，有效地对接口和实现进行了解耦。Spring框架可以注入多种数据类型，包括基本数据类型、null类型、List、Map、Set等，还可以对构造函数进行注入。并且在配置文件中改变scope的属性，可以轻松地实现单例模式（Singleton）或多实例模式（Prototype）。

Spring中还有另一个擅长的领域：AOP，下面来介绍一下在Spring中AOP的实现方法，借用上面例子中的接口和实现，代码如下：

package lizon;

public interface IService {
    public void save();
}
package service;

import lizon.IService;

public class Service implements IService {
    public void save() {
        System.out.println("保存");
    }
}

假如这个接口和实现是我们系统中多年前完成的功能模块，现在我们想在save方法中加入执行前后的日志，但是根据软件设计中对修改关闭、对扩展开放的原则，我们不应该直接修改save方法，而是使用AOP对save方法进行扩展，下面定义一个基于Spring的对方法进行增强的类：

package Interceptor;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class mylog implements MethodInterceptor{

    @Override
    public Object invoke(MethodInvocation arg0) throws Throwable {
        System.out.println("方法执行前");
        arg0.proceed();
        System.out.println("方法执行后");
        return null;
    }

}

我们定义的这个mylog的类继承自Spring中的MethodInterceptor，并重写了该类中的invoke方法，其中arg0.proceed()是执行被代理的方法，并在执行的前后加入了自定义的日志，最后我们配置一个Spring，让这个增强的方法和原方法关联起来：

<?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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd">

    <bean id="svc" class="service.Service">
    </bean>

    <bean id="mylog" class="Interceptor.mylog"></bean>

    <bean id="myproxy" class="org.springframework.aop.framework.ProxyFactoryBean">
        <property name="proxyInterfaces">
            <value>lizon.IService</value>
        </property>

        <property name="target" ref="svc"></property>

        <property name="interceptorNames">
            <list>
            <value>mylog</value>
            </list>
        </property>
    </bean>

</beans>

在这个配置文件中，首先定义了接口的实现svc和代理类mylog，然后配置代理的接口，proxyInterfaces里面的value是我们需要增强的接口，target中的ref是接口的实现，interceptorNames中配置我们使用哪一个代理类。调用方法如下：

public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        IService isvc = (IService) context.getBean("myproxy");
        isvc.save();
    }

三、Hibernate

    最后介绍一下Hibernate，首先用数据库脚本创建一个User表：

CREATE TABLE USER
(
    USERID INTEGER NOT NULL PRIMARY KEY,
    USERNAME ) NOT NULL,
    PASSWORD )
);

接着创建一个User类:

package lizon;

public class User {
    private int userid;
    private String username;
    private String password;
    public int getUserid() {
        return userid;
    }
    public void setUserid(int userid) {
        this.userid = userid;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }

}

再创建一个User.hbm.xml把User类和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="lizon.User" table="USER">
        <id name="userid" column="USERID">
            <generator class="increment"/>
        </id>
        <property name="username" column="USERNAME"></property>
        <property name="password" column="PASSWORD"></property>
    </class>
</hibernate-mapping>

添加一段代码看一下Hibernate是怎么跟数据交互的：

package lizon;

import hb4.HibernateSessionFactory;

import org.hibernate.Session;

public class Run {
    public static void main(String[] args) {

        Session session = null;
        try{
            //取得Session
            session = HibernateSessionFactory.getSession();
            //开启事务处理
            session.beginTransaction();
            //新增一个User，这时候对象是瞬时状态
            User user = new User();
            user.setUsername("lizon");
            user.setPassword("123");  

            //保存User对象 ，这时候对象是持久化状态
            session.save(user);
            //提交事务
            session.getTransaction().commit();
        }catch(Exception e){
            e.printStackTrace();
            //回滚事务
            session.getTransaction().rollback();
        }finally{
            if(session != null){
                if(session.isOpen()){
                    //关闭session，这时候的对象是游离状态
                    session.close();
                }
            }
        }
    }
}

在这段代码中，我们首先实例化了一个新的User对象，然后使用Hibernate的Session把对象保存到了数据库，甚至还包含了一个事务处理，在这中间，我们没有使用任何的sql语句，仅仅对User对象进行操作就可以持久化到数据，使用Hibernate减少了大量的重复JDBC的代码，可以更好地实现面向对象的编程，当然，这里介绍的只是Hibernate的冰山一角，由于篇幅有限，对于Hibernate的外键关联、延迟加载、HQL等有兴趣的话可以自行学习。

由于对SSH框架接触时间不长（仅一天时间，囧），难免有不周的地方，还望各位且看且珍惜。

用一天的时间学习Java EE中的SSH框架的更多相关文章

  1. java ee eclipse 配置 ssh框架

    mvnDebug tomcat:run 这条命令主要用来远程测试,它会监听远程测试用的8000端口,在eclipse里打开远程测试后,它就会跑起来了,设断点,调试,一切都是这么简单. 0.如果是mav ...

  2. 【SSH学习笔记】浅谈SSH框架

    说在前面 本学期我们有一门课叫做Java EE,由陈老师所授,主要讲的就是Java EE 中的SSH框架. 由于陈老师授课风格以及自己的原因导致学了整整一学期不知道在讲什么,所以才有了自己重新学习总结 ...

  3. Java EE中的容器和注入分析，历史与未来

    Java EE中的容器和注入分析,历史与未来 java中的容器 java中的注入 容器和注入的历史和展望 一.java中的容器 java EE中的注入,使我们定义的对象能够获取对资源和其他依赖项的引用 ...

  4. Java EE—最轻量级的企业框架?

    确保高效发展进程的建议 很久以前,J2EE,特别是应用程序服务器被认为过于臃肿和"重量级".对于开发人员来说,使用此技术开发应用程序会非常繁琐且令人沮丧.但是,由于 J2EE 框架 ...

  5. java ee 中 Jsp 页面的定时的跳转（数字倒数）

    java ee 中 Jsp 页面的定时的跳转,实现数字倒计时跳转固定页面 1,Servlet类  RefreshServlet类实现 package org.servlet; import java. ...

  6. java EE中的hello1.java及Annotation(注解)

    一.Annotation(注解) 注解(Annotation)很重要,未来的开发模式都需要注解,注解是java.lang.annotation包,Annotation是从java5引入的,它提供一些不 ...

  7. KumuluzEE - Java EE的微服务框架

    KumuluzEE - Java EE的微服务架构 https://www.jdon.com/soa/kumuluzEE.html

  8. [原创]java WEB学习笔记18：java EE 中的MVC 设计模式(理论)

    本博客为原创:综合 尚硅谷(http://www.atguigu.com)的系统教程(深表感谢)和 网络上的现有资源(博客,文档,图书等),资源的出处我会标明 本博客的目的:①总结自己的学习过程,相当 ...

  9. 如何学习java ee

    来看看Sun给出的J2EE 相关技术主要分为几大块. 1. Web Service技术 -  Java API for XML Processing (JAXP) -  Java API for XM ...

随机推荐

  1. Android系统Recovery工作原理之使用update.zip升级过程分析（一）

    通过分析update.zip包在具体Android系统升级的过程,来理解Android系统中Recovery模式服务的工作原理.我们先从update.zip包的制作开始,然后是Android系统的启动 ...

  2. 【Android】利用服务Service创建标题栏通知

    创建标题栏通知的核心代码 public void CreateInform() { //定义一个PendingIntent,当用户点击通知时,跳转到某个Activity(也可以发送广播等) Inten ...

  3. 【BZOJ1486】【HNOI2009】最小圈 分数规划 dfs判负环。

    链接: #include <stdio.h> int main() { puts("转载请注明出处[辗转山河弋流歌 by 空灰冰魂]谢谢"); puts("网 ...

  4. 15分钟学会git基本的操作命令

    http://hao.jobbole.com/try-git/ 假如你现在新创建了一个项目,想把它提交到github上面? 假设你创建好了一个项目,并切换到项目的根目录下面: $ git status ...

  5. Online ddl 思维导图

    http://blog.itpub.net/22664653/viewspace-2056953/   整理一份 MySQL DDL 的思维导图,介绍5.5版本以及之前 和 5.6 版本的 MySQL ...

  6. mysql自动备份策略

    目标:每7天做一个完整备份,每天做一份binlog日志,第二周将之前的备份删除并产生新的完整备份和binlog日志,备份要求每天2:00自动完成 mysql 版本:mysql5.5 1.开启binlo ...

  7. Linux shell 脚本攻略之正则表达式入门

    摘自:<Linux shell 脚本攻略> 下面是类似的解释:

  8. 琐碎-同步centos集群的时间

    想马上上手HBase,其对集群时间同步要求很高,当然,hadoop也是

  9. A - Robot Bicorn Attack

    Description Vasya plays Robot Bicorn Attack. The game consists of three rounds. For each one a non-n ...

  10. Android（java）学习笔记106-2：反射机制

    1.反射机制: JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法:对于任意一个对象,都能够调用它的任意一个方法和属性:这种动态获取的信息以及动态调用对象的方法的功能称为 ...