SSI框架学习

目录

目录
加载必须的包
Struts必须包

Spring必须包

iBatis必须包

mysql数据库驱动包

其他必须包

配置webxml
Struts的配置

Spring配置

配置jdbc

ssi文件配置
配置struts

配置spring的文件

配置iBatis

具体事例
事例背景

view层

DAO层
数据库连接

数据表与实体类的映射

Dao层接口

service层

Controller层

view层

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

加载必须的包

配置web.xml

jdbc配置

配置一下文件

struts.xml、

ApplicationContext.xml

SqlMap.xml

SqlConfig.cml

业务类

加载必须的包

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文件配置

<
4000
h3 id="配置struts">配置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>

然后所有的配置完成。