老兄，快来一起过春天！（六）

最新推荐文章于 2024-09-03 20:04:02 发布
最新推荐文章于 2024-09-03 20:04:02 发布
阅读量422 收藏
点赞数
分类专栏： JAVA 文章标签： spring struts bean action ibatis myeclipse
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Begin_Game/article/details/2928842
版权

Spring整合Struts1.X

 

新建web工程 composeStruts ，使用MyEclipse先后加入Struts1.2、Spring2.0
注意：选择 Spring2.0 jar包时注意将 Spring 2.0 web Libraries 导入，结构如下：

 

打开web.xml，加入Spring监听：
  <listener>
   <listener-class>
    org.springframework.web.context.ContextLoaderListener
   </listener-class>
 </listener>

 

到com.test.struts.action下新建action类：UserAction

  1. ackage com.test.struts.action;
  3. import javax.servlet.http.HttpServletRequest;
  4. import javax.servlet.http.HttpServletResponse;
  5. import org.apache.struts.action.ActionForm;
  6. import org.apache.struts.action.ActionForward;
  7. import org.apache.struts.action.ActionMapping;
  8. import org.springframework.context.ApplicationContext;
  9. import org.springframework.web.struts.ActionSupport;
  11. import com.test.spring.UserBean;
  12. import com.test.struts.form.UserForm;
  14. public class UserAction extends Action {
  15.     private UserBean userbean;  
  16.     
  17.     public ActionForward execute(ActionMapping mapping, ActionForm form,
  18.             HttpServletRequest request, HttpServletResponse response) {
  19.         UserForm userForm = (UserForm) form;
  20.         return null;
  21.     }
  23.     public UserBean getUserbean() {
  24.         return userbean;
  25.     }
  27.     public void setUserbean(UserBean userbean) {
  28.         this.userbean = userbean;
  29.     }
  30. }

到com.test.struts.form下新建form类：UserForm

  1. package com.test.struts.form;
  3. import javax.servlet.http.HttpServletRequest;
  4. import org.apache.struts.action.ActionErrors;
  5. import org.apache.struts.action.ActionForm;
  6. import org.apache.struts.action.ActionMapping;
  8. public class UserForm extends ActionForm {
  9.     
  10.     private String uname;
  11.     private String upwd;
  13.     public ActionErrors validate(ActionMapping mapping,
  14.             HttpServletRequest request) {
  15.         return null;
  16.     }
  18.     public void reset(ActionMapping mapping, HttpServletRequest request) {
  19.     }
  21.     public String getUname() {
  22.         return uname;
  23.     }
  25.     public void setUname(String uname) {
  26.         this.uname = uname;
  27.     }
  29.     public String getUpwd() {
  30.         return upwd;
  31.     }
  33.     public void setUpwd(String upwd) {
  34.         this.upwd = upwd;
  35.     }
  36. }

还需要有一个Spring管理bean，到com.test.spring下新建类：UserBean

  1. package com.test.spring;
  3. public class UserBean {
  5.     private String username;
  6.     private String userpwd;
  7.     
  8.     public String getUsername() {
  9.         return username;
  10.     }
  11.     public void setUsername(String username) {
  12.         this.username = username;
  13.     }
  14.     public String getUserpwd() {
  15.         return userpwd;
  16.     }
  17.     public void setUserpwd(String userpwd) {
  18.         this.userpwd = userpwd;
  19.     }
  20.     
  21. }

在 WebRoot下加入两个jsp文件：

index.jsp:

  1. <%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>
  2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  3. <html>
  4.   <head>
  5.     <title>Test</title>
  6.     <meta http-equiv="pragma" content="no-cache">
  7.     <meta http-equiv="cache-control" content="no-cache">
  8.     <meta http-equiv="expires" content="0">    
  9.   <body>
  10.     <a href="/testCompose/user.do">Click me</a>
  11.   </body>
  12. </html>

main.jsp:

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  3. <html>
  4.   <head>
  5.     <title>Test OK</title>
  6.     <meta http-equiv="pragma" content="no-cache">
  7.     <meta http-equiv="cache-control" content="no-cache">
  8.     <meta http-equiv="expires" content="0">
  9.   </head>  
  10.   <body>
  11.     <li><h1>name:${userForm.uname}</h1></li>
  12.     <li><h1>name:${userForm.upwd}</h1></li>
  13.   </body>
  14. </html>

打开ApplicationContext.xml，加入数据管理bean并初始化数据：
 <bean id="userbean" class="com.test.spring.UserBean" >
  <property name="username" value="admin"></property>
  <property name="userpwd" value="123456"></property>
 </bean>

 

下面开始整合工作：

Spring整合Struts1.X有三种方式，第一种是以插件形式利用Struts-Config.xml进行整合的方式：

1、改动UserAction，将父类更改为Spring中org.springframework.web.struts包下的ActionSupport类：

  1. ...
  2. public class UserAction extends ActionSupport {
  3. ...

类中有私有属性：
private UserBean userbean;
及其它相关的set、get方法，以便在Spring中注入属性。

 

接着在execute方法中加入更改代码：

  1. ApplicationContext context = getWebApplicationContext();
  2. this.setUserbean((UserBean)context.getBean("userbean"));
  3. System.out.println("用户名" + this.getUserbean().getUsername() + "    密码：" + this.getUserbean().getUserpwd());
  4. return mapping.findForward("testok");

打开Struts-Config.xml，在资源文件 <message-resources parameter="com.test.struts.ApplicationResources" /> 后加入插件：

  1.   <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
  2.     <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
  3.   </plug-in>

注意applicationContext.xml的位置，MyEclipse导入Spring后，默认是在src目录下生成此文件。如果不想移动到WEB-INF下，可以写为：

  1.   <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
  2.     <set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml"/>
  3.   </plug-in>

这样就保证了Struts-Config.xml被启动的同时也读取了applicationContext.xml。

注意，Action类继承了Spring包下的ActionSupport，而 getWebApplicationContext() 方法正是 ActionSupport 类提供的，他返回了由Struts启动的Spring配置文件上下文。因此 UserAction 通过这两句可轻易获取Spring容器，并获得需要的bean。可达到整合目的。但这样做的缺点是将Spring与Struts的距离拉近了，如Spring的xml发生变化，如beanID发生更改，那Struts的代码必须也跟着改。明显离 Spring Struts 达到 兵不识将 将不知兵的状态太远。


二、使用 DelegatingRequestProcessor 或 DelegatingActionProxy

1、将Action类改回原来继承的Struts Action类；

2、删除示例一中获得Spring上下文、获得Spring管理bean的前两句代码，保留后两句代码；

3、依然保留从Struts-Config.xml 启动Spring配置；


在Struts-Config.xml找到userAction声明：

  1.     <action
  2.       attribute="userForm"
  3.       name="userForm"
  4.       path="/user"
  5.       scope="request"
  6.       type="com.test.struts.action.UserAction" >
  7.       <forward name="testok" path="/main.jsp"></forward>
  8.   </action>

将type属性更改为：org.springframework.web.struts.DelegatingActionProxy。 

目的是把action的type设定为Spring管理的struts action代理，这样 Struts 并不与Spring 发生代码上的联系，只需要 — Spring 把请求拦截转发到 Spring 管理的相应管理bean中。


如果action比较多，每个都更改太繁琐的话，可以在资源文件声明前加上：

  1. <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor" />

使用了DelegatingRequestProcessor类，则action声明中的type属性都可以不要了，所有的Action请求都会被DelegatingRequestProcessor 自动转发。 

而这三者的顺序一定得是：
<controller .....
<message-resources .....
<plug-in .....
否则会报Struts-Config.xml的配置节点错误，虽然亦可运行，但报错始终是不大好看的。

 

Struts-Config.xml 改造好以后，回头来看ApplicationContext.xml
由于Struts通过DelegatingActionProxy代理或DelegatingRequestProcessor类将用户请求都转发到Spring来处理，Spring接收请求后，会在Context上下文查找与用户请求相关的管理bean。因此，在App...xml要需要有跟Struts-Config.xml中Action声明设定的name属性一模一样的bean。如：

Struts-Config.xml中有：

  1.     <action
  2.       attribute="userForm"
  3.       name="userForm"
  4.       path="/user"
  5.       scope="request">
  6.       <forward name="testok" path="/main.jsp"></forward>
  7.   </action>

ApplicationContext.xml中就应该有：

  1. <bean name="/user" class="com.test.struts.action.UserAction">
  2.   <property name="userbean" ref="userbean">
  3.   </property>
  4. </bean>

它们的name是一模一样的，连"/"都不能落下，否则会发生500错误，报在Spring配置上下文中找不到"/user"，发生空指针错误。还有bean中"/user"的属性只能是name,因为有反斜杠，id不能通过xml验证。

最终以插件形式一番整合下来，Struts-Config.xml内容为：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">
  4. <struts-config>
  5.   <data-sources />
  6.   <form-beans >
  7.     <form-bean name="userForm" type="com.test.struts.form.UserForm" />
  9.   </form-beans>
  11.   <global-exceptions />
  12.   <global-forwards />
  13.   <action-mappings >
  14.     <action
  15.       attribute="userForm"
  16.       name="userForm"
  17.       path="/user"
  18.       scope="request">
  19.       <forward name="testok" path="/main.jsp"></forward>
  20.   </action>
  21.   </action-mappings>
  22.   
  23.   <controller processorClass="org.springframework.web.struts.DelegatingRequestProcessor" />
  24.     
  25.   <message-resources parameter="com.test.struts.ApplicationResources" />
  26.   
  27.   <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
  28.     <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml"/>
  29.   </plug-in>
  30.   
  31. </struts-config>

ApplicationContext.xml内容为：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans
  3.     xmlns="http://www.springframework.org/schema/beans"
  4.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
  7.     <bean id="userbean" class="com.test.spring.UserBean" >
  8.         <property name="username" value="admin"></property>
  9.         <property name="userpwd" value="123456"></property>
  10.     </bean>
  11.     
  12.     <bean name="/user" class="com.test.struts.action.UserAction">
  13.         <property name="userbean" ref="userbean">
  14.         </property>
  15.     </bean>
  16. </beans>

确定无误部署到Tomcat5.5下启动，在index.jsp下点击链接，可以看到页面已成功请求到Spring管理bean，最后跳转到main.jsp页面。

 

 

控制台打印出：
用户名admin    密码：123456

 

 

Spring整合Struts2.0

 

新建工程：ComposeStruts2，结构如下：

 

一、复制jar包

到 http://struts.apache.org/download.cgi#struts20112 下载Struts2包，建议用 2.0.11.2 版本。
xwork-2.0.4.jar
struts2-spring-plugin-2.0.11.1.jar
struts2-core-2.0.11.1.jar
ognl-2.6.11.jar
freemarker-2.3.8.jar
commons-logging-1.0.4.jar

 

Spring包：

MyEclipse加入 Spring Code包 Spring Web包

 

二、Struts2、Spring启动配置

Web.xml中加入Struts2启动配置：

  1.  <display-name>Struts2Project</display-name>
  2.  <filter>
  3.   <filter-name>Struts_filter</filter-name>
  4.   <filter-class>org.apache.struts2.dispatcher.ActionContextCleanUp</filter-class>
  5.  </filter>
  6.  <filter>
  7.   <filter-name>struts2</filter-name>
  8.   <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
  9.  </filter>
  10.  <filter-mapping>
  11.   <filter-name>Struts_filter</filter-name>
  12.    <url-pattern>/*</url-pattern>
  13.   </filter-mapping>
  14.  <filter-mapping>
  15.  <filter-name>struts2</filter-name>
  16.   <url-pattern>/*</url-pattern>
  17.  </filter-mapping>

Web.xml中加入Spring启动配置：

  1.     <listener>
  2.        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  3.     </listener>
  4.     <context-param>
  5.         <param-name>contextConfigLocation</param-name>
  6.         <param-value>/WEB-INF/applicationContext.xml</param-value>
  7.   </context-param>

三、加入配置文件：
在工程src下，加入Struts配置文件：struts.xml

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE struts PUBLIC
  3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  4.     "http://struts.apache.org/dtds/struts-2.0.dtd">
  6. <struts>
  7.     <constant name="struts.objectFactory" value="spring" />
  8.     <include file="struts-default.xml"/>
  9.     <package name="default" extends="struts-default">
  10.         <action name="user" class="useraction">
  11.             <result name="testok">/main.jsp</result>
  12.         </action>
  13.     </package>
  14. </struts>

可以看到Struts2已经配置指定了Action的对象实例由Spring工厂产生，因此在下面action的class声明中已经不需要指定属性class的路径，指定路径的工作交由ApplicationContext.xml文件完成，Struts.xml只需要将Spring管理的Action类的beanid赋给class就可以了。

在WEB-INF下打开Spring配置文件：applicationContext.xml，在beans节点下加入

  1.     <bean id="usermodel" class="com.test.model.UserModel">
  2.         <property name="username" value="admin"></property>
  3.         <property name="userpwd" value="123456"></property>
  4.     </bean>
  5.     
  6.     <bean id="useraction" class="com.test.struts.action.UserAction" >
  7.         <property name="usermodel" ref="usermodel"></property>
  8.     </bean>

三：
在model下新建usermodel类：

  1. package com.test.model;
  3. public class UserModel {
  4.     
  5.     private String username;
  6.     private String userpwd;
  7.     
  8.     public String getUsername() {
  9.         return username;
  10.     }
  11.     public void setUsername(String username) {
  12.         this.username = username;
  13.     }
  14.     public String getUserpwd() {
  15.         return userpwd;
  16.     }
  17.     public void setUserpwd(String userpwd) {
  18.         this.userpwd = userpwd;
  19.     }
  21. }

在action包下新建useraction类：

  1. package com.test.struts.action;
  3. import com.opensymphony.xwork2.ActionSupport;
  4. import com.test.model.UserModel;
  6. public class UserAction extends ActionSupport {
  7.     
  8.     private UserModel usermodel;
  9.     private String errorstr;
  11.     public String execute() throws Exception {
  12.         if(usermodel.getUsername().equals("admin") && usermodel.getUserpwd().equals("123456")){
  13.             System.out.println("验证通过");
  14.             this.setErrorstr("TestOK");
  15.         }
  16.         else{
  17.             this.setErrorstr("Test Error");
  18.         }
  19.         return "testok";
  20.     }
  22.     public UserModel getUsermodel() {
  23.         return usermodel;
  24.     }
  26.     public void setUsermodel(UserModel usermodel) {
  27.         this.usermodel = usermodel;
  28.     }
  30.     public String getErrorstr() {
  31.         return errorstr;
  32.     }
  34.     public void setErrorstr(String errorstr) {
  35.         this.errorstr = errorstr;
  36.     }
  38. }

WebRoot下新建2个jsp文件

index.jsp

  1. <%@ page language="java" pageEncoding="UTF-8"%>
  2. <%@taglib uri="/struts-tags" prefix="s" %>
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  4. <html>
  5.   <head>
  6.     <title>Test struts2</title>
  7.     <meta http-equiv="pragma" content="no-cache">
  8.     <meta http-equiv="cache-control" content="no-cache">
  9.     <meta http-equiv="expires" content="0">    
  10.   </head>
  11.   
  12.   <body>
  13.     <a href="/ComposeStruts2/simple/user.action">Click me</a>
  14.   </body>
  15. </html>

main.jsp

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%@taglib uri="/struts-tags" prefix="s" %>
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  4. <html>
  5.   <head>
  6.     <title>Test OK</title>
  7.     <meta http-equiv="pragma" content="no-cache">
  8.     <meta http-equiv="cache-control" content="no-cache">
  9.     <meta http-equiv="expires" content="0">
  10.   </head>
  11.   <body>
  12.     <s:iterator id="usermodel" value="user">
  13.         <s:property value="username" />
  14.         <s:property value="userpwd" />
  15.     </s:iterator>
  16.     Test Result:  <s:property value="errorstr" />
  17.   </body>
  18. </html>

将工程部署到Tomcat下运行，如果单击 Click me 发生无法找到action的404错误，打开一下Tomcat目录 webapps 下的工程目录，打开web-inf下的lib，查看是否存在 log4j-x.x.x.jar 、asm 包，如果存在删除即可。

如无意外单击 Click me 链接后可看到链接通过 Struts.xml 中action节点定义的class属性，在ApplicationContext中找到与之相同的Spring管理bean，由此达到 Spring 管理 Struts Action 类的目的。

 

程序最终运行到 main.jsp ：

        Test Result: TestOK

如在ApplicationContext将UserModel初始值改变，将得到

       Test Result: TestError

 

Spring 管理 Ibatis

 

一、数据库准备（Oracle）：

新建数据库
create table userinfo
(
   userid number(2),
   username varchar2(15),
   upwd varchar2(40)
)
插入测试数据
insert into userinfo values(1,'test1','123456')
insert into userinfo values(2,'test2','654321')

 

新建工程 ComposeIbatis，结构如图：

 

增加Myeclipse下Spring包，注意把COREAOP/WEB/，以及最重要的IBATIS ORM包导入
增加Struts2的jar包
增加 DB 驱动jar包

 

web.xml 下加入启动 Spring  Struts

  1.     ...........
  2. <display-name>Struts2Project</display-name>
  3.     <filter>
  4.         <filter-name>Struts_filter</filter-name>
  5.         <filter-class>org.apache.struts2.dispatcher.ActionContextCleanUp</filter-class>
  6.     </filter>
  7.     <filter>
  8.         <filter-name>struts2</filter-name>
  9.         <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
  10.     </filter>
  11.     <filter-mapping>
  12.         <filter-name>Struts_filter</filter-name>
  13.             <url-pattern>/*</url-pattern>
  14.         </filter-mapping>
  15.     <filter-mapping>
  16.     <filter-name>struts2</filter-name>
  17.         <url-pattern>/*</url-pattern>
  18.     </filter-mapping>
  19.     
  20.     <listener>
  21.        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  22.     </listener>
  23.     <context-param>
  24.         <param-name>contextConfigLocation</param-name>
  25.         <param-value>/WEB-INF/applicationContext.xml</param-value>
  26.     </context-param>
  27. ................

在src下新建 struts.xml Struts配置文件：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE struts PUBLIC
  3.     "-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
  4.     "http://struts.apache.org/dtds/struts-2.0.dtd">
  6. <struts>
  7.     <constant name="struts.objectFactory" value="spring" />
  8.     <include file="struts-default.xml"/>
  9.     <package name="default" extends="struts-default">
  10.         <action name="user" class="useraction">
  11.             <result name="testok">/main.jsp</result>
  12.         </action>
  13.     </package>
  14. </struts>

Struts.xml的配置中已经设定所有Struts对象将从Spring产生，如：在请求定义为 user 的 Action 时，系统会到 Spring 中查找id与之Action声明中的class属性相同的bean，将请求转发到这个bean中处理。

 

在struts包下放置action类及业务service类；

  1. package com.test.struts.action;
  3. import java.util.List;
  5. import com.opensymphony.xwork2.ActionSupport;
  6. import com.test.struts.service.UserService;
  8. public class UserAction extends ActionSupport {
  10.     private UserService user; 
  11.     private List userlist;
  13.     public String execute() throws Exception {
  14.         List list = user.getUserInfo();
  15.         this.setUserlist(list);
  16.         
  17.         return "testok";
  18.     }
  20.     public UserService getUser() {
  21.         return user;
  22.     }
  24.     public void setUser(UserService user) {
  25.         this.user = user;
  26.     }
  28.     public List getUserlist() {
  29.         return userlist;
  30.     }
  32.     public void setUserlist(List userlist) {
  33.         this.userlist = userlist;
  34.     }
  35. }

这个类有一个属性需要 Spring 注入 － private UserService user; 在ApplicationContext.xml 中加入依赖注入：

  1. <bean id="useraction" class="com.test.struts.action.UserAction">
  2.     <property name="user" ref="user_service"></property>
  3. </bean>

而注入是用ref 注入的，意味着 ApplicationContext.xml 中还应该有管理bean user_service。

暂且不管，在service包下加入业务service类UserService：

  1. package com.test.struts.service;
  3. import java.util.List;
  5. import com.test.dao.IUserDao;
  7. public class UserService {  
  8.     private IUserDao dao;   
  9.     public List getUserInfo()
  10.     {
  11.         List list = null;
  12.         list = dao.getUserInfo();       
  13.         return list;
  14.     }
  15.     public synchronized IUserDao getDao() {
  16.         return dao;
  17.     }
  18.     public synchronized void setDao(IUserDao dao) {
  19.         this.dao = dao;
  20.     }
  21. }

将这个服务类做为Spring管理bean user_service，这个bean就是 useraction 需要注入的bean：

  1.     <bean id="user_service" class="com.test.struts.service.UserService">
  2.         <property name="dao" ref="iBatisDao"></property>
  3.     </bean>

而 UserService.java 类也有注入属性 dao ，于是管理bean 也用另外一个管理 bean  iBatisDao 进行了依赖注入 。

暂且不管管理bean iBatisDao 的声明，到dao包下新建接口IUserDao：

  1. package com.test.dao;
  3. import java.util.List;
  5. public interface IUserDao {
  6.     public List getUserInfo();  
  7. }

及impl包下的接口实现类 UserImpl ：

  1. package com.test.dao.impl;
  3. import java.util.List;
  4. import com.test.ibatis.sqlmap.StaticSqlString;
  6. import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;
  8. import com.test.dao.IUserDao;
  10. public class UserImpl extends SqlMapClientDaoSupport implements IUserDao {
  12.     public List getUserInfo() {
  13.         List list = null;
  14.         list = this.getSqlMapClientTemplate().queryForList(StaticSqlString.getSELECT_ALL_USER());
  15.         System.out.println(list.size());        
  16.         return list;
  17.     }
  18. }

注意 UserImpl  除了实现IUserDao 接口外，还集成了一个特殊的类：SqlMapClientDaoSupport 。 它是Spring提供的一个将Ibatis对象SqlMapClient 进行包装了的对象，使用这个对象将不会再去理会 SqlException ，SqlException将在这个类中得到Spring的处理，而它的使用方法完全与SqlMapCliect一样。而bean user_service 需要注入的bean iBatisDao 将用这个实现类进行注入。

  1.     <!-- 使用iBatis实现的DAO -->
  2.     <bean id="iBatisDao" class="com.test.dao.impl.UserImpl">
  3.         <property name="sqlMapClient">
  4.             <bean class="org.springframework.orm.ibatis.SqlMapClientFactoryBean">
  5.                 <property name="configLocation">
  6.                     <value>classpath:com/test/ibatis/sqlmap/sqlMapConfig.xml</value>
  7.                 </property>
  8.                 <property name="dataSource" ref="dataSource" />
  9.             </bean>
  10.         </property>
  11.     </bean>

SqlMapClientDaoSupport 在Spring 配置中声明时，需要注入sqlMapClient实例，因此需要将 得到 IBatis 的配置文件 sqlMapConfig.xml 与数据库连接dataSource配置的sqlMapClient示例进行依赖注入。

 

下面是数据库连接bean:dataSource:

  1.     <!-- 定义DataSource -->
  2.     <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
  3.         <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver" />
  4.         <property name="url" value="jdbc:oracle:thin:@10.132.224.XXX:1521:XXXX" />
  5.         <property name="username" value="XXXXX" />
  6.         <property name="password" value="XXXXX" />
  7.     </bean>

 

到此 Spring 管理 Ibatis 的整合完成。

 

到 model 包下新建 Ibatis 数据模型类：UserModel －对应数据库表：userinfo表

  1. package com.test.model;
  3. import java.sql.Date;
  5. public class UserModel {
  6.     
  7.     private String userid;
  8.     private String username;
  9.     private String upwd;
  10.     public String getUserid() {
  11.         return userid;
  12.     }
  13.     public void setUserid(String userid) {
  14.         this.userid = userid;
  16.     ..............
  18.         this.upwd = upwd;
  19.     }
  21. }

到 sqlmap 包下新建 Ibatis 配置文件：sqlMapConfig.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE sqlMapConfig SYSTEM "http://www.ibatis.com/dtd/sql-map-config-2.dtd">
  4. <sqlMapConfig>
  5.     <sqlMap resource="com/test/ibatis/xml/x_test.xml" />
  6. </sqlMapConfig>

sqlmap包下新建负责传递Ibatis 需要的sql语句id类：StaticSqlString

  1. package com.test.ibatis.sqlmap;
  3. public class StaticSqlString {  
  4.     private static String SELECT_ALL_USER = "s_all_user";
  5.     public static synchronized String getSELECT_ALL_USER() {
  6.         return SELECT_ALL_USER;
  7.     }
  8.     public static synchronized void setSELECT_ALL_USER(String select_all_user) {
  9.         SELECT_ALL_USER = select_all_user;
  10.     } 
  11. }

到xml包下新建Ibatis 查询配置文件：x_test.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE sqlMap SYSTEM "http://www.ibatis.com/dtd/sql-map-2.dtd">
  3. <sqlMap>
  4.     <typeAlias alias="userinfo"
  5.         type="com.test.model.UserModel" />
  6.     <select id="s_all_user" resultClass="userinfo">
  7.         <![CDATA[
  8.             SELECT * FROM USERINFO
  9.         ]]>
  10.     </select>
  11. </sqlMap>

到webRoot下新建jsp文件：

index.jsp:

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%@taglib uri="/struts-tags" prefix="s" %>
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  4. <html>
  5.   <head>    
  6.     <title>Test</title>
  7.   </head>  
  8.   <body>
  9.     <a href="/ComposeIbatis/user.action">Click Me</a>
  10.   </body>
  11. </html>

main.jsp:

  1. <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
  2. <%@taglib uri="/struts-tags" prefix="s" %>
  3. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
  4. <html>
  5.   <head>    
  6.     <title>Test OK</title>    
  7.   </head>  
  8.   <body>
  9.     <table>
  10.         <s:iterator id="user" value="userlist">
  11.         <tr>
  12.             <td><s:property value="userid" /></td>
  13.             <td><s:property value="userame" /></td>
  14.             <td><s:property value="upwd" /></td>
  15.         </tr>
  16.         </s:iterator>
  17.     </table>
  18.   </body>
  19. </html>

部署运行，点击Click Me 提交请求到user.action ，请求将从Struts 转发到 Spring 管理 Bean 中，通过 Spring 的 SqlMapClientTemplate 获取到数据库数据，转而呈现在页面上。
Begin_Game
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ReactFirebaseBook:“老兄！ 从Firebase示例代码页开始的无服务器React开发
05-02
“老兄！ 从Firebase开始的无服务器React开发示例代码 该存储库是在技术手册7中分发的douujinshi“ Riakt！”。 从Firebase开始的无服务器React开发示例代码。该手册可在以下站点上购买。 :warning:使用示例代码的...
aterwinwin:您以前的废话可能恰恰是其他人想要的，反之亦然，所以让这些事情动起来，你们所有人都可以成为老兄！
03-13
总的来说，学习和使用TypeScript不仅能提升开发者的编程体验，也能提高代码质量和团队协作的效率。通过参与和研究aterwinwin项目，你可以深入了解TypeScript在实际项目中的应用，并从中获得宝贵的经验。
老兄，快来一起过春天！（八）
10-13 446
Spring集成Xfire 用XFire 打造webServices 一：下载XFire1.26官网地址：http://xfire.codehaus.org/Download下载 xfire-distribution-1.2.6.zip 与 xfire-all-1.2.6.jar 包，如单独下载jar包，会发生譬如找不到Spring依赖或Ant依赖等少包问题，因此最好把依赖ja
老兄，快来一起过春天！（七）
10-10 276
打开 Spring2.0管理Ibatis 文中所建的工程：ComposeIbatis找到接口 IUserDao.java ，增加方法：public void addUserInfo(); 用于增加用户操作。其实现类：UserImpl.java 实现 addUserInfo() 方法，在业务类 UserService 中调用，而Struts的action调用业务类。所有改动如下：一、IUse
老兄，快来一起过春天！（一）
09-04 303
     很有趣，spring 中文理解可为“春天”。     2005 java中间件世界由于spring横空出世，重量级EJB应用似乎岌岌可危，各种轻量级应用如：PicoContainer、Avalonwei已经微不足道了。转瞬过了3年，spring亦从2.0披上了2.5战衣，而3.0也引人侧目、呼之欲出，java的春天渐有横扫六合之霸王之相。      那么，spring中微醉的
老兄，快来一起过春天！（四）
09-10 329
 AOP：面向切面编程 OOP主要是通过对象继承、多态的特点，来进行强大的代码重用。而AOP是将整体的系统分成各个不同模块，形成不同的切面来进行程序设计。 如Struts中数据层的每个方法，就算使用各种ORM框架，如：...........boolean backbool = false;daoManager.startTransaction();try{  ....... d
node-cribbage:准备好接受臭鼬了吗，老兄？
06-04
【标题】"node-cribbage:准备好接受臭鼬了吗，老兄？"指的是一个基于Node.js开发的游戏项目，可能是以臭鼬牌戏（Cribbage）为主题。这个项目的名称带有幽默感，暗示用户可能在体验过程中遇到一些意想不到的乐趣或者...
后来老兄「Later Dude」-crx插件
03-24
推迟到适当的时候，我们会提醒你 支持语言:English
老兄阻拦「Big Brother Blocker」-crx插件
03-20
这个插件将删除最流行的芬兰新闻网站的所有大哥哥和BB相关的内容。 该扩展程序将从mtv.fi，iltasanomat.fi，iltalehti.fi和hs.fi新闻网站中查找与BB或“老大哥”相关的内容，并将其删除。查看屏幕截图。...
Ibatis 批处理笔记
09-04 2168
因为近期牵涉到有可能大批量更新数据的操作，于是找来Ibatis看了一下其中的批量存储，发现批处理。 代码片段：....try{    this.startBatch();                for (String str : list) {         this.update(UP_USER_STATE, str);    }
GWT 记录 之 Google plugin for Eclipse开发环境
10-05 1013
1：将Google plugin for eclipse 通过eclipse自动更新安装到eclipse。 google plugin for eclipse 最新版本为3.5，但稳定起见，最好使用低一个版本的。官方自动更新站点为：http://dl.google.com/eclipse/plugin/3.4 。 eclipse的内核版本必须为3.3以上，现在IDE为myeclip
wicket一些基础控件代码
12-26 956
努力学习中，没什么总结，仅限记录！wicket对所有控件设定都存放与Server，不知好是不好，感觉有些不靠谱！package com.wicket.page;import java.awt.Graphics2D;import java.awt.image.renderable.RenderableImage;import java.io.IOException;import java.io.Se
Proxool c3p0 连接池配置
10-21 906
Proxool 连接池 ：xml version="1.0" encoding="UTF-8"?> something-else-entirely>proxool>alias>DBPoolalias>driver-url>jdbc:mysql://localhost:3306/schoolproject?useUnicode=truecharacterEnc
试试Wicket
12-21 573
wicket环境已到1.5bate版本。但鉴于资料太少以及个人时间安排，只有下了1.4版本，借鉴着王磊先生的《wicket开发指南》摸索着学习，感谢王磊先生的免费翻译制作！wicket1.4下 download:  http://www.apache.org/dyn/closer.cgi/wicket/1.4-rc1环境配置与struts spring大同小异，在web.xml中写入启动插件，实现
老兄，快来一起过春天！（五）
09-12 497
使用 Spring AOP ，配置ApplicationContext.XML 实在是繁杂而乏味的工作。如果有多于10个切入点需要AOP代理，可以想象XML中的装配需要声明多少个切入bean，每个切入点需要4个增强，就需要40个切入点声明。而在aop装配中，也需要把这些声明一一写到注入的list中。因此，在大部分情况下，应该使用一些AOP框架来简化这些AOP装配。譬如：AspectJ。As
老兄，快来一起过春天！（三）
09-07 353
打开testspring工程新建包：com.testspring.message   放置存放各种消息的propertise文件。新建包：com.testspring.services   放置获取propertise文件的服务类。 结构如下： message包下新建：message_en_US.properties文件。加入以下内容：    say = hel
老兄，快来一起过春天！（二）
09-06 279
依赖注入的注入类型可以注入基本类型、集合、类、甚至程序要使用的资源。下面的例子可以看到applicationContext.xml中注入的各种类型。在上一篇已经构造好的目录上增加一个util包，新建类 TestOK 。TestOK 代码如下：package com.testspring.util;public class TestOK {        public String testsay(
SpringBoot Web请求响应
最新发布
今心上的博客
09-03 868
请求 响应 分层解耦
oracle 自动生成流水号
12-06
Oracle可以通过序列（Sequence）来实现自动生成流水号的功能。序列是一个数据库对象，它可以生成一系列唯一的数字，常用于生成主键或其他需要唯一标识的字段值。下面是两种生成流水号的方法： 1. 使用序列和触发器 首先创建一个序列，例如： ```sql CREATE SEQUENCE SEQ_TEST_A INCREMENT BY 1 START WITH 1 MAXVALUE 99999999 CYCLE CACHE 10; ``` 然后创建一个触发器，在插入数据时自动获取序列的下一个值并插入到指定的字段中，例如： ```sql CREATE OR REPLACE TRIGGER TRG_TEST_A BEFORE INSERT ON TEST_A FOR EACH ROW BEGIN SELECT SEQ_TEST_A.NEXTVAL INTO :NEW.SERIAL_NUMBER FROM DUAL; END; ``` 这样，在插入数据时，就会自动获取序列的下一个值并插入到`SERIAL_NUMBER`字段中。 2. 使用`sys_guid()`函数 `sys_guid()`函数可以生成一个全局唯一的GUID值，可以用作主键或其他需要唯一标识的字段值。例如： ```sql INSERT INTO TEST_A (ID, SERIAL_NUMBER) VALUES (sys_guid(), 'ABC123'); ``` 这样，每次插入数据时，都会生成一个全局唯一的ID值，并将指定的流水号插入到`SERIAL_NUMBER`字段中。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值