SSI框架学习

原创 2015年10月22日 20:17:25

目录

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文件里面配置以下代码即可:

 <!-- 配置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>

Spring配置

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

<!-- 配置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>

  <!-- 配置spring -->
  <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <listener>
        <listener-class>org.apache.struts2.dispatcher.ng.listener.StrutsListener</listener-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文件。

<?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.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为常用的参数配置,而


<constant name="struts.convention.package.locators.basePackage"
value="com.neusoft.demo.action" />

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

配置spring的文件

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

web.xml文件如下所示:

<?xml version="1.0" encoding="UTF-8"?>
<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>TEST1</display-name>

  <!-- 配置spring的context -->
   <context-param>         
        <param-name>contextConfigLocation</param-name>        
        <param-value>             
            /WEB-INF/applicationContext.xml        
        </param-value>
   </context-param>

    <!-- 中文过滤 -->    
   <filter>    
        <filter-name>characterEncoding</filter-name>    
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>    
        <init-param>    
            <param-name>encoding</param-name>    
            <param-value>utf-8</param-value>    
        </init-param>    
        <init-param>    
            <param-name>forceEncoding</param-name>    
            <param-value>true</param-value>    
        </init-param>    
    </filter>    
    <filter-mapping>    
        <filter-name>characterEncoding</filter-name>    
        <url-pattern>/*</url-pattern>    
    </filter-mapping>

  <!-- 配置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>

  <!-- 配置spring -->
  <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  </listener>

  <listener>
        <listener-class>org.apache.struts2.dispatcher.ng.listener.StrutsListener</listener-class>
  </listener>


  <welcome-file-list>
    <welcome-file>index.html</welcome-file>
    <welcome-file>index.htm</welcome-file>
    <welcome-file>index.jsp</welcome-file>
    <welcome-file>default.html</welcome-file>
    <welcome-file>default.htm</welcome-file>
    <welcome-file>default.jsp</welcome-file>
  </welcome-file-list>
</web-app>

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

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

<?xml version="1.0" encoding="UTF-8" ?> 
<!DOCTYPE sqlMapConfig PUBLIC "-//ibatis.apache.org//DTD SQL Map Config 2.0//EN"
"http://ibatis.apache.org/dtd/sql-map-config-2.dtd">
 <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>,每一个sqlmap的内容如下所示:

<sqlMap>

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

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

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


</sqlMap> 

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


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

具体事例

事例背景

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

view层

登录失败界面:
登录界面

登录成功界面:
这里写图片描述

登录失败界面:
这里写图片描述

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

DAO层

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

数据库连接

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

<bean 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}" />
</bean>

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

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


}

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

<sqlMap>

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

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

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

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

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

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


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


</sqlMap> 

然后我们需要将该映射关系配置到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.xml</value>
        </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<User> 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<User> 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层配置。

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

这里将实体类和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<User> 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<User> queryAll() {

        return userdao.queryAll();
    }

    @Override
    public boolean updateUser(User user) {

        return userdao.updateUser(user);
    }





}

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

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

其中,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<User> 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<User> getUserlist() {
        return userlist;
    }

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

}

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

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

这样,将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"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<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"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<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"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<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.jsp</result>             <!-- 注册失败 -->
        <result name="error">error.jsp</result>
    </action>

    <action name="query" class="loginAction" method="queryUser">             <!-- 注册成功 -->
        <result name="success">select.jsp</result>             <!-- 注册失败 -->
        <result name="error">error.jsp</result>
    </action>

</package>     

然后所有的配置完成。

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

SSI框架

框架的结构分析:框架结构图(是在网上找到的),我自己感觉相对比较清晰。 我分别解释一下每层所涉及的内容和各个层次之间的交互情况。 顶层表现层,对于java开发而言,主要代表的是jsp和html...

ssi框架学习总结(mvc三层架构)

相信大家对于mvc的三层架构已经灰常熟悉了,在这就不细讲了,个人感觉ssi的框架结构还是比较典型的mvc三层架构,还是比较容易上手的 相信大家对于mvc的三层架构已经灰常熟悉...

ssi框架学习个人小结

  • 2017年03月10日 23:21
  • 147KB
  • 下载

SSI框架小实例,实现增删改查

struts2+spring+ibatis框架整合的小实例,实现增删改查操作

SSI框架下,用jxl实现导出功能

SSI框架下用JXL实现导出功能

SSI整合--搭建Struts2+Spring+Ibatis框架

web.xml
  • dqsweet
  • dqsweet
  • 2012年07月27日 18:33
  • 4064

【转】手把手构建Maven企业级应用(整合SSI框架)

网上其实整合框架的资料其实很多的,但是其中整合SSI的相对比较少的,如果是用Maven整合的就是少之又少的,如果是用Maven构建的企业级应用(多模块开发)整合SSI框架的实例基本上是没有的,所以写下...
  • gouding
  • gouding
  • 2012年03月22日 12:54
  • 952

ssi框架相关内容

MVC对于我们来说,已经不陌生了,它起源于20世纪80年代针对smalltalk语言的一种软件设计模式,现在已被广泛应用。近年来,随着java的盛行,MVC的低耦合性、高重用性、可维护性、软件工程的可...
  • gj716
  • gj716
  • 2015年05月12日 22:14
  • 332

SSI框架中配置log4j

其实主要是log4j配置,跟SSI关系不大。 web.xml中添加 log4jConfigLocation /WEB-INF/localconf/log4j.properti...

SSI框架中遇到的问题

1、Caused by: java.lang.ClassNotFoundException: com.mchange.v2.c3p0.ComboPooledDataSource
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SSI框架学习
举报原因:
原因补充:

(最多只允许输入30个字)