SSH 框架的搭建

Structs1+spring+Hibernate

Structs 相当于mvc设计模式中V.C，即jsp页面和Servlet；

spring 管理业务逻辑，即Service；

Hibernate 管理DAO,持久层；

首先讲一下Hibernate和spring的整合：

　　1.加入相关的jar：mysql的 mysql-connector-java-5.1.13-bin.jar；

　　　　　　　　　　 Hibernate的就不一一列出的（上一篇文章有提到);特别注意的是要导slf4j相关的底层实现包 slf4j-nop-1.5.8.jar

　　　　　　　　　　 spring的相关jar（spring\reqlib底下所有，spring\spring-framework-3.1.0.RC1-with-docs\spring-framework-3.1.0.RC1\dist底下所有）;

　　2.提供spring的配置文件。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:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

         http://www.springframework.org/schema/context

         http://www.springframework.org/schema/context/spring-context-3.0.xsd

         http://www.springframework.org/schema/aop

         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <context:annotation-config />

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <context:component-scan base-package="com"></context:component-scan>

</beans>

　　3.配置数据库连接池。

<?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:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

         http://www.springframework.org/schema/context

         http://www.springframework.org/schema/context/spring-context-3.0.xsd

         http://www.springframework.org/schema/aop

         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <context:annotation-config />

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <context:component-scan base-package="com"></context:component-scan>

    <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"

        destroy-method="close">

        <property name="driverClassName" value="com.mysql.jdbc.Driver" />

        <property name="url" value="jdbc:mysql://127.0.0.1:3306/mysql" />

        <property name="username" value="root" />

        <property name="password" value="root" />

    </bean>

</beans>

　　此时，写个测试类，测试下。（前提是数据库已存在表格t_user）；

package Test;

import java.sql.Connection;

import java.sql.SQLException;

import org.apache.commons.dbcp.BasicDataSource;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class T {

    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        BasicDataSource dataSource = ac.getBean("myDataSource",BasicDataSource.class);

        Connection conn;

        try {

            conn = dataSource.getConnection();

            conn.createStatement().executeUpdate("insert into t_user values(null,'arron','1234')");

        } catch (SQLException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

}

　　4.配置sessionFactory;

<?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:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

         http://www.springframework.org/schema/context

         http://www.springframework.org/schema/context/spring-context-3.0.xsd

         http://www.springframework.org/schema/aop

         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <context:annotation-config />

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <context:component-scan base-package="com"></context:component-scan>

<!--配置数据库连接池-->

    <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"

        destroy-method="close">

        <property name="driverClassName" value="com.mysql.jdbc.Driver" />

        <property name="url" value="jdbc:mysql://127.0.0.1:3306/mysql" />

        <property name="username" value="root" />

        <property name="password" value="root" />

    </bean>

<!--配置sessionFactory-->

    <bean id="mySessionFactory" class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

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

    <property name="packagesToScan" value="com.kebin.pojo">

    </property>

    <property name="hibernateProperties">

      <props>

          <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>

                <prop key="hibernate.show_sql">true</prop>

                <prop key="hibernate.format_sql">true</prop>

                <prop key="hibernate.hbm2ddl.auto">update</prop>

                <prop key="hibernate.current_session_context_class">thread</prop>

      </props>

    </property>

  </bean>

</beans>

　　配置完成了，写了User pojo类，和测试类，测试下。

User.java

package com.kebin.pojo;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name="t_user")

public class User {

    private int id;

    private String name;

    private String password;

    @Id

    @GeneratedValue

    public int getId() {

        return id;

    }

    public void setId(int id) {

        this.id = id;

    }

    public String getName() {

        return name;

    }

    public void setName(String name) {

        this.name = name;

    }

    public String getPassword() {

        return password;

    }

    public void setPassword(String password) {

        this.password = password;

    }

}

T.java

package Test;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.kebin.pojo.User;

public class T {

    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        SessionFactory sf = ac.getBean("mySessionFactory",SessionFactory.class);

        Session session = sf.getCurrentSession();

        Transaction ts = session.beginTransaction();

        ts.begin();

        User user = new User();

        user.setName("admin");

        user.setPassword("123456");

        session.save(user);

        ts.commit();

    }

}

　　接着往下写业务逻辑层。

UserDao.java

package com.kebin.dao;

import com.kebin.pojo.User;

public interface UserDao {

    public void save(User user);

}

UserDaoImpl.java

package com.kebin.dao;

import org.springframework.stereotype.Component;

import com.kebin.pojo.User;

@Component("userDao")

public class UserDaoImpl implements UserDao {

    public void save(User user) {

        // TODO Auto-generated method stub

    }

}

UserService.java

package com.kebin.service;

import com.kebin.pojo.User;

public interface UserService {

    public void add(User user);

}

　　书写一个DaoSupport类继承自HibernateTemplate；

package com.kebin.dao;

import javax.annotation.Resource;

import org.hibernate.SessionFactory;

import org.springframework.orm.hibernate3.HibernateTemplate;

import org.springframework.stereotype.Component;

@Component

public class DaoSupport extends HibernateTemplate {

    private SessionFactory sessionFactory;

    @Resource(name="mySessionFactory")

    public void setSessionFactory(SessionFactory sessionFactory) {

        super.setSessionFactory(sessionFactory);

    }

}

UserServiceImpl

package com.kebin.service.impl;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.kebin.dao.DaoSupport;

import com.kebin.dao.UserDao;

import com.kebin.pojo.User;

import com.kebin.service.UserService;

@Service("userService")

public class UserServiceImpl extends DaoSupport implements UserService {

    private UserDao userDao;

    @Resource(name="userDao")

    public void setUserDao(UserDao userDao) {

        this.userDao = userDao;

    }

    public void add(User user) {

        this.save(user);

    }

}

　　最后写个测试类T.java，进行测试下。这样hibernate和spring就配置好了。

package Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.kebin.pojo.User;

import com.kebin.service.UserService;

public class T {

    public static void main(String[] args) {

        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = ac.getBean("userService",UserService.class);

        User user = new User();

        user.setName("kebin");

        user.setPassword("1111111");

        userService.add(user);

    }

}

接下来，讲一下Spring 和 Struts 的整合

我这里用的是Struts1,可能很多公司都已经不用了的。

　　1.导入Struts的包，struts1\struts-1.3.10-all\struts-1.3.10\lib底下所有的包。

　　　（有两个包和hibernate重复了，删除就可以了。commons-logging.jar 和 antlr-2.7.6.jar 留下版本高的）；

　　2.拷入struts-config.xml配置文件；

　　　　（将struts-config.xml和applicationContext.xml都放在WEB-INF的底下）

　　3.书写UserAction.java和index.jsp页面。代码我直接贴出；

UserAction.java

package com.kebin.action;

import javax.annotation.Resource;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;

import org.apache.struts.action.DynaActionForm;

import org.apache.struts.actions.DispatchAction;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.stereotype.Controller;

import com.kebin.pojo.User;

import com.kebin.service.UserService;

@Controller

@Qualifier("/user")

public class UserAction extends DispatchAction {

    private UserService userService;

    @Resource(name = "userService")

    public void setUserService(UserService userService) {

        this.userService = userService;

    }

    public ActionForward execute(ActionMapping mapping, ActionForm form,

            HttpServletRequest request, HttpServletResponse response)

            throws Exception {

        DynaActionForm df = (DynaActionForm) form;

        // 配置了注解，直接将userService注入，这段读取的代码就不用了；

        // ApplicationContext ac = WebApplicationContextUtils.getRequiredWebApplicationContext(this.getServlet().getServletContext());

        // UserService userService = ac.getBean("userService",UserService.class);

        User user = new User();

        user.setName(df.getString("username"));

        user.setPassword(df.getString("password"));

        userService.add(user);

        return mapping.findForward("success");

    }

}

index.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"

    pageEncoding="UTF-8"%>

<!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=UTF-8">

<title>Insert title here</title>

</head>

<body>

    <form action="user.do?command=login" method="post">

        username:<input type="text" name="username"/><br>

        password:<input type="text" name="password"/><br>

        <input type="submit" value="tijiao">

    </form>

</body>

</html>

　　4.配置web.xml;(注意中文乱码的配置)；

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

    http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">

    <servlet>

        <servlet-name>action</servlet-name>

        <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

        <init-param>

            <param-name>config</param-name>

            <param-value>/WEB-INF/struts-config.xml</param-value>

        </init-param>

        <load-on-startup>2</load-on-startup>

    </servlet>

    <!-- 配置spring的监听器，用以实现依赖注射 -->

    <listener>

        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

    </listener>

    <!-- 配置spring的配置文件的读取路径 -->

    <context-param>

        <param-name>contextConfigLocation</param-name>

        <param-value>/WEB-INF/applicationContext.xml</param-value>

    </context-param>

    <!-- 借用spring 实现对中文乱码的修改 -->

    <filter>

        <filter-name>Set Character Encoding</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>

    </filter>

    <filter-mapping>

        <filter-name>Set Character Encoding</filter-name>

        <url-pattern>*.do</url-pattern>

    </filter-mapping>

    <!-- action 的配置     -->

    <servlet-mapping>

        <servlet-name>action</servlet-name>

        <url-pattern>*.do</url-pattern>

    </servlet-mapping>

    <welcome-file-list>

        <welcome-file>index.jsp</welcome-file>

    </welcome-file-list>

</web-app>

　　5.配置applicationContext.xml;（这里只要加个bean标签，来代替action-mappings里面的action中type=""）;

<?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:context="http://www.springframework.org/schema/context"

    xmlns:aop="http://www.springframework.org/schema/aop"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

         http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

         http://www.springframework.org/schema/context

         http://www.springframework.org/schema/context/spring-context-3.0.xsd

         http://www.springframework.org/schema/aop

         http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

    <context:annotation-config />

    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

    <context:component-scan base-package="com"></context:component-scan>

    <!--配置数据库连接池 -->

    <bean id="myDataSource" class="org.apache.commons.dbcp.BasicDataSource"

        destroy-method="close">

        <property name="driverClassName" value="com.mysql.jdbc.Driver" />

        <property name="url" value="jdbc:mysql://127.0.0.1:3306/mysql" />

        <property name="username" value="root" />

        <property name="password" value="root" />

    </bean>

    <!--配置sessionFactory -->

    <bean id="mySessionFactory"

        class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">

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

        <property name="packagesToScan" value="com.kebin.pojo">

        </property>

        <property name="hibernateProperties">

            <props>

                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</prop>

                <prop key="hibernate.show_sql">true</prop>

                <prop key="hibernate.format_sql">true</prop>

                <prop key="hibernate.hbm2ddl.auto">update</prop>

                <prop key="hibernate.current_session_context_class">thread</prop>

            </props>

        </property>

    </bean>

    <!-- 用注解来代替struts-config.xml配置文件中action的type="com.kebin.action.UserAction" -->

    <bean name="/user" class="com.kebin.action.UserAction"></bean>

</beans>

　　6.配置struts-config.xml；

<?xml version="1.0" encoding="UTF-8" ?>

<!DOCTYPE struts-config PUBLIC

          "-//Apache Software Foundation//DTD Struts Configuration 1.3//EN"

          "http://struts.apache.org/dtds/struts-config_1_3.dtd">

<struts-config>

    <form-beans>

        <form-bean name="login" type="org.apache.struts.action.DynaActionForm">

            <form-property name="username" type="java.lang.String"></form-property>

            <form-property name="password" type="java.lang.String"></form-property>

        </form-bean>

    </form-beans>

    <action-mappings>

        <action path="/user" name="login"

            parameter="command">

            <forward name="success" path="/ok.jsp"></forward>

        </action>

    </action-mappings>

<!-- 用注解来代替action-mappings配置中action标签对里的type="com.kebin.action.UserAction(此处)" -->

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

    </controller>

    <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">

        <set-property property="contextConfigLocation" value="/WEB-INF/applicationContext.xml" />

    </plug-in>

</struts-config>

以上给出简单列子的配置，基本的配置已经完成。谢谢各位大牛给出宝贵的评价。

SSH 框架的搭建的更多相关文章

Struts2+Spring+Hibernate(SSH)框架的搭建
首先需要下载struts2 ,spring4,hibernate5 的资源包; struts2资源包下载路径:http://www.apache.org/spring资源包下载路径:http://p ...
ssh框架简单搭建
这里是个人对SSH框架搭建的一点心得,仅供新手,勿喷首先,搞清楚分层, 视图层 --> 控制层 --> 业务层 --> DAO层--> 持久层搭建的顺序是从后向前,搭建一 ...
ssh框架的搭建
SSH 为 struts+spring+hibernate的一个集成框架,是目前较流行的一种Web应用程序开源框架. 集成SSH框架的系统从职责上分为四层:表示层.业务逻辑层.数据持久层和域模块层,以 ...
SSH框架的搭建和测试（Spring + Struts2 + Hibernate）
SSH框架实现了视图.控制器.和模型的彻底分离,同时还实现了业务逻辑层与持久层的分离. Spring实现了MVC中的 Controller的功能,Struts实现Web视图的功能,Hibernate则 ...
struts2+spring+hibernate(SSH)框架的搭建和总结
SSH框架:struts2+spring+hibernate,是目前较流行的一种Web应用程序开源集成框架,用于构建灵活.易于扩展的多层Web应用程序. struts2+spring+hibernat ...
SSH框架环境搭建问题：java.lang.IllegalArgumentException: 'sessionFactory' or 'hibernateTemplate' is required
SSH框架启动tomcate时出错严重: Exception sending context initialized event to listener instance of class org. ...
SSH框架环境搭建问题：Line: 230 - com/opensymphony/xwork2/spring/SpringObjectFactory.java:230:-1
只是通过myeclipse搭建一个框架而已启动tomcat时报错信息: File: SpringObjectFactory.java Method: getClassInstance Line: 2 ...
SSH框架快速搭建（Maven）
1.新建Maven项目ssh 2.pom.xml <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi=& ...
SSH框架的搭建与配置文件的书写格式
通常Java Web 开发的时候,我们一般会采用三大框框架的整合来架构,这样做主要是为方便维护.但是有时候会忘了一些配文件(*.xml)的格式头,这里主要就三大框架Spring.struts.hibe ...
转 SSH框架搭建详细图文教程
原址:http://blog.sina.com.cn/s/blog_a6a6b3cd01017c57.html 什么是SSH? SSH对应 struts spring hibernatestruts ...

随机推荐

C++学习——类当中static关键字的作用
一.类和对象我们知道类是"行为"和"属性"的集合,我们可以通过类来实例化对象,从而定义对象的"行为"和"属性".比如: ...
PC大屏自适应
通常来说PC端的页面并不像移动端页面那样对屏幕大小和分别率有那么强的依赖.一般的页面都是取屏幕中间的一块宽度(1280px), 两边留白, 高度随着内容的长度滚动.这样无论窗口怎么变化,页面都是可用的 ...
[这可能是最好的Spring教程！]Maven的模块管理——如何拆分大项目并且用parent继承保证代码的简介性
问题的提出在软件开发中,我们为了减少软件的复杂度,是不会把所有的功能都塞进一个模块之中的,塞在一个模块之中对于软件的管理无疑是极其困难且复杂的.所以把一个项目拆分为模块无疑是一个好方法 ┌ ─ ─ ...
解密prompt系列43. LLM Self Critics
前一章我们介绍了基于模型自我合成数据迭代,来提升LLM生成更合理的自我推理思考链路.但在模型持续提升的道路上,只提升Generator能力是不够的,需要同步提升Supervisor.Verifier的 ...
使用 fiddler 进行抓包处理
1.概述 fiddler是一个抓包工具,有时候方便我们在访问网页上,看看网页的参数和返回结果.其中很重要的一条是,可以查看网页的响应速度,在对于调优方面提供一些依据. 2.软件安装我们可以通过360 ...
Nuxt.js 应用中的 beforeResponse 事件钩子
title: Nuxt.js 应用中的 beforeResponse 事件钩子 date: 2024/12/5 updated: 2024/12/5 author: cmdragon excerpt: ...
原创单总线传输协议b2s （附全部verilog源码）
一.b2s协议背景介绍本单总线传输协议为精橙FPGA团队原创,含传送端(transmitter)和接收端(receiver)两部分,基于verilog语言,仅使用单个I/O口进行多位数据的传输,传输 ...
cas5配置redis
POM文件加载redis依赖,重新maven clean package <dependency> <groupId>org.apereo.cas</groupId&g ...
对象存储COS成本优化方案
随着上云企业越来越多,企业对用云成本问题也越发重视.业务的发展会产生海量存储需求,在云端存储数据时,如何进行成本优化,减轻业务负担呢? 在进行成本优化之前,首先需要了解腾讯云对象存储COS的成本构成. ...
动态 import()
动态 import() https://v8.dev/features/dynamic-import Dynamic import() 引入了一个新的类似函数的功能,相比静态的 import 提供了新 ...

SSH 框架的搭建

SSH 框架的搭建的更多相关文章

随机推荐

热门专题