SSI框架学习

目录

SSI框架是指struts、spring、ibatis整合到一起，来构建javaWeb的过程，下面我们从以下几个步骤来说明如何架构javaWeb项目，具体如下：

1. 加载必须的包
2. 配置web.xml
3. jdbc配置

4. 配置一下文件
   struts.xml、
   ApplicationContext.xml
   SqlMap.xml
   SqlConfig.cml

5. 业务类

---

加载必须的包

Struts必须包

struts框架的必须包，我们可以从网上下载下来，网上所下载下来的包，我们可以发现，

这里面有很多包，但并不是所有都是我们必须要的，我们只需要导入我们所需要的包即可，如下图所示，

Spring必须包

对于Spring架包同样可以从网上下载可得，我们这里只给出他的必须包,

iBatis必须包

对于iBatis必须包只有一个，iBatis主要负责对数据库的关联和操作的，如下图所示，

mysql数据库驱动包

常用的数据库有DB2、Oracle、mysql等等，对于个人所应用的一般为mysql，而企业所用大多为前两种，这里驱动mysql的包为：

mysql-connector-java-5.16.jar

根据自己所用的mysql版本，选用所对应的架包。

其他必须包

下面给出一些其他用到的数据包

• c3p0 ：数据库连接池
• dom4j ： 解析xml文件
• log4j ：日志文件的架包
• struts2-spring-plugin ：绑定struts和spring的架包

对于以上架包，我们直接将jar文件复制到 webcontent/web-inf/lib文件夹下面，刷新即可导入架包

配置web.xml

导入架包之后，我们需要在web.xml文件里面配置struts和spring

Struts的配置

在web.xml文件里面配置以下代码即可：

 
  <filter>
        <filter-name>struts2filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilterfilter-class>
  filter>

  <filter-mapping>
        <filter-name>struts2filter-name>
        <url-pattern>/*url-pattern>
  filter-mapping>

Spring配置

在web.xml文件中配置Spring，而web.xml文件中配置的内容有前后顺序之别，而Spring文件的配置内容需在Struts的内容后面，即

  <filter>
        <filter-name>struts2filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilterfilter-class>
  filter>

  <filter-mapping>
        <filter-name>struts2filter-name>
        <url-pattern>/*url-pattern>
  filter-mapping>

  
  <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>

  <listener>
        <listener-class>org.apache.struts2.dispatcher.ng.listener.StrutsListenerlistener-class>
  listener>

配置jdbc

配置jdbc主要是给出数据库的相关属性文件，来连接数据库，这部分是spring来连接数据池的，该文件的内容主要用来连接数据库
jdbc.properties:

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/数据库名字
jdbc.username=root
jdbc.password=密码

对于默认的数据库，数据库名字为root，密码为自己安装时所用的密码，而127.0.0.1位当地网址，对于远程的数据库，则需要用远程的地址，3306为数据库的端口号。
对于其他不同的数据库，各自有不同的配置文件。

注意：属性的前后左右不能有空格！！！不然会出现错误。

ssi文件配置

配置struts

根据个人理解，该文件的作用主要是用来部署前端表单所用来连接的action，首先给出空的struts.xml文件。

<struts>
    <constant name="struts.objectFactory" value="spring" />    
    <constant name="struts.i18n.encoding" value="UTF-8" />    
    <constant name="struts.i18n.reload" value="false" />    
    <constant name="struts.configuration.xml.reload" value="false" />    
    <constant name="struts.custom.i18n.resources" value="globalMessages" />    
    <constant name="struts.action.extension" value="action,," />    

    <constant name="struts.convention.package.locators.basePackage"    
              value="com.neusoft.demo.action" />    
    <constant name="struts.convention.result.path" value="/" />    
    <constant name="struts.serve.static" value="true" />    
    <constant name="struts.serve.static.browserCache" value="false" />    

struts>  

其中，constant为常用的参数配置，而


value="com.neusoft.demo.action" />

该配置文件中，value为action所在的包

配置spring的文件

spring的配置文件为applicationContext.xml，该文件作用非常重要，用来配置数据库连接池，配置数据库与具体类的连接，具体类与前端的连接。即数据层 —实体—前端的连接，该Context文件需要在web.xml文件中进行配置。
在web.xml文件中配置context（上下文），添加如下代码，该配置内容在web.xml文件的最前端, 并给出中文过滤器。

web.xml文件如下所示：

<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>TEST1display-name>

  
   <context-param>         
        <param-name>contextConfigLocationparam-name>        
        <param-value>             
            /WEB-INF/applicationContext.xml        
        param-value>
   context-param>

        
   <filter>    
        <filter-name>characterEncodingfilter-name>    
        <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>    
        <init-param>    
            <param-name>encodingparam-name>    
            <param-value>utf-8param-value>    
        init-param>    
        <init-param>    
            <param-name>forceEncodingparam-name>    
            <param-value>trueparam-value>    
        init-param>    
    filter>    
    <filter-mapping>    
        <filter-name>characterEncodingfilter-name>    
        <url-pattern>/*url-pattern>    
    filter-mapping>

  
  <filter>
        <filter-name>struts2filter-name>
        <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilterfilter-class>
  filter>

  <filter-mapping>
        <filter-name>struts2filter-name>
        <url-pattern>/*url-pattern>
  filter-mapping>

  
  <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
  listener>

  <listener>
        <listener-class>org.apache.struts2.dispatcher.ng.listener.StrutsListenerlistener-class>
  listener>


  <welcome-file-list>
    <welcome-file>index.htmlwelcome-file>
    <welcome-file>index.htmwelcome-file>
    <welcome-file>index.jspwelcome-file>
    <welcome-file>default.htmlwelcome-file>
    <welcome-file>default.htmwelcome-file>
    <welcome-file>default.jspwelcome-file>
  welcome-file-list>
web-app>

web.xml文件基本配置完成，而applicationContext.xml的空文件配置如下，

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

配置iBatis

iBatis的配置文件为SqlMapConfig.xml，该文件主要用来将数据库的列与实体类的成员变量对应，并且用别名来表示相关的操作语句，这样在对象操作过程中，不需要再用繁琐的语句，而直接用别名来操作即可，直接传入别名，来进行操作？？？

SqlMapConfig.xml

 

 <sqlMapConfig>
    <settings cacheModelsEnabled="false" enhancementEnabled="false"
        lazyLoadingEnabled="false" maxRequests="3000" maxSessions="3000"
        maxTransactions="3000" useStatementNamespaces="true" /> 
  
 <sqlMap resource="com/demo/map/User.xml" /> 
 sqlMapConfig>

在这里，我们运用语句：

<sqlMap resource="com/demo/map/User.xml" /> 

这里就是将总体框架与配置文件分离，我们可以在开发过程中自己定义好资源文件，然后插入到这个映射文件，该文件的主体就是,每一个sqlmap的内容如下所示：

   class="com.czbank.demo.user.User" id="User">
         <result property="userid" column="useid"/>
         <result property="username" column="usename"/>
         <result property="password" column="password"/>
    

    alias="User" type="com.czbank.demo.user.User" />

    id="selectUser" parameterClass="String" resultClass="User">
    select * from USER where usename = #username#;     
    


 

首先将实体类的成员变量和数据库中相应的列来匹配，然后定义每一个语句，插入、删除、添加等等都有自己特定的标记。另外还可以做一些特殊的标记。

---

自此，SSI框架的3个基本配置文件已经给出，然后根据具体的操作来进行配置。

具体事例

事例背景

我们给定一个页面，用户输入自己的名字和密码，可以进行登录，我们现在只是实现简单的登录功能，即登录成功和登录失败。

view层

登录失败界面：

登录成功界面：

登录失败界面：

对于以上逻辑关系，我们可以简单的归纳为，网页提交表单，用户名和密码，然后后台做出反应来判断是否成功和失败，成功和失败如何跳转，从以上分析来看，判断功能，我们要通过访问数据库来判断是否有该用户，关于如何跳转，我们在struts文件里面进行配置跳转的属性，这也就是所谓的DAO层

DAO层

Data Access Object 数据访问层，DAO层主要是做数据持久层的工作，负责与数据库进行联络的一些任务都封装在此，DAO层的设计首先是设计DAO的接口，然后在Spring的配置文件中定义此接口的实现类，然后就可在模块中调用此接口来进行数据业务的处理，而不用关心此接口的具体实现类是哪个类，显得结构非常清晰，DAO层的数据源配置，以及有关数据库连接的参数都在Spring的配置文件中进行配置 。

数据库连接

数据库的连接在spring的配置文件里面，由于jdbc.properties已经给出了数据库的属性文件，我们只需要调用其中的属性来配置即可，这样就减少了如果改换数据库带来的改动麻烦，只需要在.properties文件里面改动属性即可。

id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"
    destroy-method="close">
    <property name="driverClass" value="${jdbc.driverClass}" />
    <property name="jdbcUrl" value="${jdbc.url}" />
    <property name="user" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />


id="propertyConfig"       class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location">
        WEB-INF/jdbc.properties
    property>

applicationContext文件里面都是以bean为单位的，这两个bean将数据源配置起来。固定做法。

数据表与实体类的映射

数据库连接好之后，我们需要对数据库中不同的表建立不同的数实体类映射，如下图所示：
表user：

我们发现该列表中有3列，所以我们要建立实体类来与数据库中的列表建立映射关系，为什么这样做？？因为前端提交的表单不能直接作用到数据库的表中，我们建立与表映射的实体类对象，这样可以直接操作实体类对象。

user对象：

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


}

而对该对象与数据库的映射关系，我们通过来进行配置.
userMap.xml

   class="com.neusoft.demo.pojo.User" id="User">
         <result property="userid" column="useid"/>
         <result property="username" column="usename"/>
         <result property="password" column="password"/>
     

    alias="User" type="com.neusoft.demo.pojo.User" />

    id="selectUser" parameterClass="String" resultClass="User">
    select * from USER where usename = #username#;     
    

    id="insertUser" parameterClass="User">
        insert into USER(ID,USERNAME,PASSWORD)values(#userid#,#username#,#password#)
    

    id="deleteUser" parameterClass="int">
        delete from USER where ID = #userid#
    

    id="updateUser" parameterClass="User">
        update USER set USERNAME=#username#,PASSWORD=#password# where ID = #userid#
    


    id="queryAll" parameterClass="User" resultClass="User">
        select * from USER
    


 

然后我们需要将该映射关系配置到iBatis中的sqlmapconfig中去，

 <sqlMap resource="com/neusoft/demo/map/User.xml" /> 

然后将sqlmapconfig添加到spring的配置文件applicationContext中，则将映射配置成功。

    <bean id="sqlMapClient" class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
        <property name="configLocation">
            <value>WEB-INF/SqlMapConfig.xmlvalue>
        property>         

        <property name="dataSource">
            <ref bean="dataSource" />
        property>
    bean>

Dao层接口

表和类的映射，以及表的具体sql语句和别名的映射，而作用到具体的user类，我们需要实现对具体user类的操作，那么就是所谓的Dao层接口。实现对user的具体操作，而接口中常用的方法：select、insert、delete和update，因此给出抽象的接口，具体实现类分开处理。我们实现的是与类user的交互。

userDao.java

import java.util.List;

import com.neusoft.demo.pojo.User;

public interface UserDao {


    public User queryByname(String name); //查询一条数据 

    public List queryAll(); //查询一张表的所有数据 

    public boolean insertUser(User user); //增加一个用户

    public boolean updateUser(User user); //修改用户 

    public boolean deleteUser(int id);  //删除用户


}

而给出特定的实现类.

userDaoImpl.java

public class UserDaoImpl extends SqlMapClientDaoSupport implements UserDao {

     @Override  
     public User queryByname(String name) {         
         try {            
            Object queryForObject = getSqlMapClientTemplate().queryForObject("selectUser", name);
            User user =(User) queryForObject;     
            return user;    
         } catch (Exception e) {      
           e.printStackTrace();           
           return null;         
         }  
     }

    @Override
    public boolean deleteUser(int id) {
            boolean b;
            try{
                getSqlMapClientTemplate().delete("deleteUser",id);
              b = true;
            }catch(Exception e){
              e.printStackTrace();
              b = false;
            }
            return b;
    }

    @Override
    public boolean insertUser(User user) {
        boolean b;
        try {
            getSqlMapClientTemplate().insert("insertUser", user);
              b = true;
            } catch (Exception e) {
              e.printStackTrace();
              b = false;
            }
            return b ;
    }

    @Override
    public List queryAll() {

        List list = null;
        try {
            list = getSqlMapClientTemplate().queryForList("queryAll");
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    @Override
    public boolean updateUser(User user) {
        boolean b ;
        try {
          getSqlMapClientTemplate().update("updateUser", user);
          b = true;
        } catch (Exception e) {
          b = false;
        }
        return b;
    } 

}

这样即实现了数据库与实体类的交互，Dao层的作用是给出了所有以后可能用到的接口。然后在spring文件中将Dao层配置。

  id="userdaoId" class="com.neusoft.demo.daoimpl.UserDaoImpl">
    <property name="sqlMapClient" ref="sqlMapClient">property>
  

这里将实体类和sqlMapClient映射起来，而在实际的运用中，我们并不一定要用到所有的接口，所以这里有一个service层

service层

Service层是建立在DAO层之上的，建立了DAO层后才可以建立Service层，而Service层又是在Controller层之下的，因而Service层应该既调用DAO层的接口，又要提供接口给Controller层的类来进行调用，它刚好处于一个中间层的位置。每个模型都有一个Service接口，每个接口分别封装各自的业务处理方法。 Service层选择实际业务用到的接口，并用DAO层实体类实现，而Service层的接口可以直接被Controller层所运用，起到承上启下的作用。Service层一般先给出接口，然后给出具体类实现该接口，而该接口类直接被Controller层所运用。

Service层接口：

public interface UserServices {


    public User querybyname(String name);

    public List queryAll(); //查询一张表的所有数据 

    public boolean insertUser(User user); //增加一个用户

    public boolean updateUser(User user); //修改用户 

    public boolean deleteUser(int id);  //删除用户 

}

这里我们只需要把具体需要的类的接口给出，并不需要将Dao层的接口的方法都给出，而具体的实现类的方法，调用Dao层的类来实现。

public class UserServicesImpl implements UserServices {

    private UserDao userdao;

    public void setUserdao(UserDao userdao) {
        this.userdao = userdao;
    }

    public UserDao getUserdao() {
        return userdao;
    }

    @Override
    public User querybyname(String name) {

        return userdao.queryByname(name);
    }

    @Override
    public boolean deleteUser(int id) {

        return userdao.deleteUser(id);
    }

    @Override
    public boolean insertUser(User user) {

        return userdao.insertUser(user);
    }

    @Override
    public List queryAll() {

        return userdao.queryAll();
    }

    @Override
    public boolean updateUser(User user) {

        return userdao.updateUser(user);
    }





}

如上，利用Dao层的userDaoimpl来实现该service层的具体方法，然后在spring中配置service层，实现他们的关联。

id="userServicesId" class="com.neusoft.demo.servicesimpl.UserServicesImpl">
        <property name="userdao" ref="userdaoId">
        property>
     

其中，property为类中的成员变量，而成员变量的类型，则与上方定义的Dao层所关联。至此Dao层和Service层配置完成，而这两个层为Model层。下面看是Controller层，即业务逻辑层，而逻辑层操作的对象为service层。

Controller层

Controller层负责具体的业务模块流程的控制，在此层里面要调用Service层的接口来控制业务流程，然后与view层进行交互，我们要将view层所提交的表单，用service层进行相关的操作。

例如，在本例中，我们通过来判断用户名和密码的正确与否来进行登录，在action中给出方法判断逻辑关系，并返回ERROR，INPUT，NONE，SUCCESS，LOGIN五个字符串常量，该5个常量用来判断跳转的页面，这在struts.xml文件里面进行配置，首先给出Action类，由于action为struts的核心接口，而ActionSupport完美实现了该接口的要求，所以我们可以直接集成ActionSupport作为控制器。

具体action类实现，action的变量分别对应http请求表单里面的参数。

public class LoginAction extends ActionSupport{

    private UserServicesImpl userServicesImpl; 

    private int userid;  
    private String password; 
    private String username;
    private List userlist;


    public String loginUser() {

        String username = this.username;
        String password = this.password;
        User user = userServicesImpl.querybyname(username);
        if (user != null && password.equals(user.getPassword())) {
            return SUCCESS;
        } else
            return ERROR;
    }

    public String queryUser(){

         userlist=userServicesImpl.queryAll();

         this.setUsername(userlist.get(0).getUsername());
         this.setPassword(userlist.get(0).getPassword());
         System.out.print("Password"+this.getPassword()+"   ");
         System.out.print("userlist"+userlist);
        if(userlist != null){
            return SUCCESS;
        }else
           return ERROR;
    }

    public UserServicesImpl getUserServicesImpl() {
        return userServicesImpl;
    }

    public void setUserServicesImpl(UserServicesImpl userServicesImpl) {
        this.userServicesImpl = userServicesImpl;
    }

    public int getUserid() {
        return userid;
    }

    public void setUserid(int userid) {
        this.userid = userid;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public List getUserlist() {
        return userlist;
    }

    public void setUserlist(List userlist) {
        this.userlist = userlist;
    }

}

然后在spring中applicationContext.xml文件中配置action的情况，

id="loginAction" name="loginAction"
        class="com.neusoft.demo.action.LoginAction" scope="prototype">
        <property name="userServicesImpl" ref="userServicesId">property>
      

这样，将Controller层和model层联系到一起，可以定义多个action，然后action与页面进行交互，下面就是配置view层，然后将view层和Controller层联系到一起，即在struts.xml文件里面配置action的跳转情况，

view层

view层的实现大多以jsp实现，下面给出登录的页面，以及跳转后简单的页面，
login.jsp

<%@ page language="java" contentType="text/html; charset=gb2312"%>
<%@ taglib prefix="s" uri="/struts-tags"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>登陆界面title>
head>
<body>
Hello World!
<div align="center"><s:form method="post" action="login.action">

    <table id="table1" border="1" cellpadding="0" cellspacing="0"
        width="300">

        <tr>
            <td width="100%" bgcolor="#C0C0C0" align="center"><font
                color="#0000FC">用户登录font>td>
        tr>

        <tr> 
            <s:textfield label="用户名" name="username" />
        tr>

        <tr>
            <s:password label="密码" name="password" />
        tr>
        <tr>
        <s:submit value="提交" />
        tr>
    table>

s:form>div>
body>
html>

这里采用了struts的标签。

success.jsp

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>成功title>
head>
<body>
登陆成功！
<a href="query.action?method=queryUser">查询用户a>
<a href="">增加用户a>
<a href="./index.jsp">注销a>


body>
html>

error.jsp

<%@ page language="java" contentType="text/html; charset=GBK"
    pageEncoding="GBK"%>

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>失败 title>
head>
<body>
登陆失败 ！
body>
html>

下面在struts.xml文件中将Controller层和view层联系到一起，然后

package name="" namespace="/" extends="struts-default">
    <action name="login" class="loginAction" method="loginUser">             
        <result name="success">success.jspresult>             
        <result name="error">error.jspresult>
    action>

    <action name="query" class="loginAction" method="queryUser">             
        <result name="success">select.jspresult>             
        <result name="error">error.jspresult>
    action>

package>     

然后所有的配置完成。