深入浅出Struts2+Spring+Hibernate框架

一、深入浅出Struts2

  • 什么是Struts2?

　　　　struts2是一种基于MVC的轻量级的WEB应用框架。有了这个框架我们就可以在这个框架的基础上做起，这样就大大的提高了我们的开发效率和质量，为公司节省了不少的人力成本。

  • 为什么使用Struts2?

　　　　struts2实现了视图与业务应用逻辑的解耦(软件工程的高内聚，低耦合原则)。

　　　　在Model 1时代，开发web项目我们都是在JSP里写入处理业务逻辑的JAVA代码，尤其像涉及到数据库和页面form表单数据之间交互的时候，每次都要写连接、查询、增加、修改、删除等数据库代码。有各种如HTML与Java，JavaScript在一个页面的，可读性差，重复，多余，耦合，性能差，不易维护等各种问题。让我们观察model1与model2的不同：

model 1的程序流程

　　　　到Model2时代，JSP不再承担控制器的责任。它仅仅是表现层角色，仅仅用于将结果呈现给客户，JSP页面的请求与Servlet(控制器)交互，而Servlet负责与后台 的Javabean通信。在Model2模式下，模型(Model)由JavaBean充当，视图(View)由JSP页面充当，而控制器(Controller)则由Servlet充当，Model2模式也叫“MVC模式”。

　　　　　　　　　　　　　　　　　　　　　　　　model 2 程序流程

　　　　　　在后来开发者根据Model2模式开发出了一个框架，那就是我们现在用的Struts2。控制器(Contoller)由FilterDispather充当，模型(Model)由Action充当,视图(View)由Result来充当，这样实现了与Servlet API的解耦，使得ACtion的单元测试更加简单，而且强大的类型转换也使得我们少做了很多重复的工作。下图是Struts2 MVC结构：　　　　　　　　　　　　　　　　　　　　

  Struts2的请求周期：

1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求

2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）

3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action

FilterDispatcher是控制器的核心，就是mvc中c控制层的核心。下面粗略的分析下我理解的FilterDispatcher工作流程和原理：FilterDispatcher进行初始化并启用核心doFilter

4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy

5、ActionProxy通过ConfigurationManager询问框架的配置文件，找到需要调用的Action类 ,这里，我们一般是从struts.xml配置中读取。

6、ActionProxy创建一个ActionInvocation的实例。

7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。

  • Struts2的两种配置方式

　　　　配置就像程序的影子，与程序总是与影随行。大部分框架技术，配置总是作为其中重要的组成部分，在框架的运行中发挥作用。声明应用程序有两种不同的方式，XML和注解的方式。

XML配置方式：

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>

    <package name="mypackage" extends="struts-default">
        <action name="myNews6Action_*" class="myNews6Action" method="{1}">
            <result name="success">/WEB-INF/jsp/index.jsp</result>
            <result name="deleteok">/WEB-INF/jsp/ok.jsp</result>
            <result name="deleteon">/WEB-INF/jsp/error.jsp</result>
        </action>
    </package>
</struts>

Action类只要继承ActionSupport类：

package myNews6.action;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;

import com.opensymphony.xwork2.ActionSupport;

import myNews6.entity.News;
import myNews6.service.MyNews6Service;

@Controller
@Scope("prototype")
public class MyNews6Action extends ActionSupport {
    @Autowired
    private MyNews6Service mns;
    private List<News> list;
    private Integer id;

    public List<News> getList() {
        return list;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getAllNews(){
        list=mns.getAllNews();
        return "success";
    }

    public String deleteNewsById(){
        String value=mns.deleteNewsById(id);
        return value;
    }
}

注解配置方式：

要使用注解方式必须添加一个额外包：struts2-convention-plugin-2.x.x.jar。

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.1.7//EN"
    "http://struts.apache.org/dtds/struts-2.1.7.dtd"> 

<struts>
    <!-- 请求参数的编码方式-->
    <constant name="struts.i18n.encoding" value="UTF-8"/>
    <!-- 指定被struts2处理的请求后缀类型。多个用逗号隔开-->
    <constant name="struts.action.extension" value="action,do,htm"/>
    <!-- 当struts.xml改动后，是否重新加载。默认值为false(生产环境下使用),开发阶段最好打开  -->
    <constant name="struts.configuration.xml.reload" value="true"/>
    <!-- 是否使用struts的开发模式。开发模式会有更多的调试信息。默认值为false(生产环境下使用),开发阶段最好打开  -->
    <constant name="struts.devMode" value="false"/>
    <!-- 设置浏览器是否缓存静态内容。默认值为true(生产环境下使用),开发阶段最好关闭  -->
    <constant name="struts.serve.static.browserCache" value="false" />
    <!-- 指定由spring负责action对象的创建
    <constant name="struts.objectFactory" value="spring" />
    -->
    <!-- 是否开启动态方法调用-->
    <constant name="struts.enable.DynamicMethodInvocation" value="false"/>
</struts>

action类的注解：

/**
 * Struts2基于注解的Action配置
 *
 */
@ParentPackage("struts-default")
@Namespace("/annotation_test")
@Results( { @Result(name = "success", location = "/main.jsp"),
        @Result(name = "error", location = "/error.jsp") })
@ExceptionMappings( { @ExceptionMapping(exception = "java.lange.RuntimeException", result = "error") })
public class LoginAction extends ActionSupport {
    private static final long serialVersionUID = 2730268055700929183L;
    private String loginName;
    private String password;   

    @Action("login") //或者写成  @Action(value = "login")
    public String login() throws Exception {   

        if ("yjd".equals(loginName) && "yjd".equals(password)) {
            return SUCCESS;
        } else {
            return ERROR;
        }
    }
    @Action(value = "add", results = { @Result(name = "success", location = "/index.jsp") })
    public String add() throws Exception {
        return SUCCESS;
    }
    public String getLoginName() {
        return loginName;
    }
    public void setLoginName(String loginName) {
        this.loginName = loginName;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password= password;
    }
}

这样就完成了一个基于注解的action配置。

　　　　Struts2的两种配置都可以达到同样的效果，只不过xml是把配置外部，annotation是把配置内部化，他们各自的优缺点、适用场合应该是很明显的。 如果一个配置只是用来描述某个组件本身的属性，那么annotation优先，比如hibernate、validate；优点是配置和组件往往需要同时修改，放在一起便于维护、保证一致性；反之，如果配置是描述一堆组件如何协作、关联，或者很难说清是针对哪个组件的，那么应该用xml，比如spring配置。优点是配置集中、架构清晰、维护配置不需修改组件代码，反之亦然。

  • SpringMVC替换Struts2

springMVC的请求周期：

1、客户端发出一个http请求给web服务器，web服务器对http请求进行解析，如果匹配DispatcherServlet的请求映射路径（在web.xml中指定），web容器将请求转交给DispatcherServlet.

2、DipatcherServlet接收到这个请求之后将根据请求的信息（包括URL、Http方法、请求报文头和请求参数Cookie等）以及HandlerMapping的配置找到处理请求的处理器（Handler）。

3-4、DispatcherServlet根据HandlerMapping找到对应的Handler,将处理权交给Handler（Handler将具体的处理进行封装），再由具体的HandlerAdapter对Handler进行具体的调用。

5、Handler对数据处理完成以后将返回一个ModelAndView()对象给DispatcherServlet。

6、Handler返回的ModelAndView()只是一个逻辑视图并不是一个正式的视图，DispatcherSevlet通过ViewResolver将逻辑视图转化为真正的视图View。

7、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端

springMVC搭建的例子：

1. jar包引入

　　Spring 2.5.6：spring.jar、spring-webmvc.jar、commons-logging.jar、cglib-nodep-2.1_3.jar等；

1、配置web.xml
指除了Control层外的其它Bean的Spring配置文件，定义DispatcherServlet。这里是把spring与spring mvc的功能随着服务器启动而启动；
<?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">
    <!-- 除了Control层外的其它Bean的Spring容器设置，这个与SSH整合的时候一样 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

    <!-- 配置DispatcherServlet -->
    <!-- 名字为mvc，那么我们在WEB-INF中需要一个名为mvc-servlet.xml的spring mvc配置文件来对Control层的Bean、相关页面以及Spring mvc提供的一些工具Bean进行管理 -->
    <servlet>
        <servlet-name>mvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <!-- 接收页面以.abc结尾的请求 -->
    <servlet-mapping>
        <servlet-name>mvc</servlet-name>
        <url-pattern>*.abc</url-pattern>
    </servlet-mapping>

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

2、编写处理请求的Controller(处理器)

package cn.framelife.mvc.control;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import cn.framelife.mvc.entity.User;

/**
 * @Controller 通过Spring的自动扫描功能，把一个POJO转化为处理请求的控制器
*通过@RequestMapping标注，可以将特定的url和具体的controller类或controller类中的方法绑定。
 * @RequestMapping("/user") 处理来自/user的请求,一般来说是用于区分不同模块的
 */
@Controller
@RequestMapping("/user")
public class UserControl {

    /**
     * 处理/user的请求，请求的方法为POST
     * 参数的User对象是把页面的表单值放进一个User对象中
     * ModelAndView 是返回一个View。在这里我们是一个JSP页面。
     */
    @RequestMapping(method=RequestMethod.POST)
    public ModelAndView createUser(User user){
        System.out.println(user.getUsername()+"-"+user.getPassword());

        //ModelAndView.setViewName("/success") 根据mvc的配置文件，可知返回的是/user/success.jsp
        ModelAndView view = new ModelAndView();
        view.setViewName("/success");

        //把一个user对象放到ModelAndView中
        user.setUsername("li");
        view.addObject(user);
        return view;
    }
}

3、编写视图文件 
我们在WebRoot/uesr目录下有一个add.jsp及一个success.jsp页面。add.jsp是用以表单输入。而success.jsp是Controller处理完后返回的页面。 
add.jsp:

<body>
    <form action="user.abc" method="post">
        用户名：<input type="text" name="username"><br/>
        密 码：<input type="text" name="password"><br/>
        <input type="submit">
    </form>
  </body>
success.jsp:
<body>
    success!!${user.username}.
  </body>

4、配置Spring MVC的配置文件，使控制器、视图解析器等生效

mvc-servlet.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:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    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
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
    <!-- 扫描控制器 -->
    <context:component-scan base-package="cn.framelife.mvc.control"></context:component-scan>

    <!-- 视图名称解析器 -->
    <!--
        Controller中：ModelAndView.setViewName("/success")
        配置的是/user/success.jsp
     -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
        p:prefix="/user"
        p:suffix=".jsp"></bean>
</beans>


5、配置其它的Bean 
诸如service层、dao层等Bean在applicationContext.xml中配置，如我们之前做的工作一样。



SpringMVC和Struts2的区别


1、Struts2是类级别的拦截， 一个类对应一个request上下文，SpringMVC是方法级别的拦截，一个方法对应一个request上下文，而方法同时又跟一个url对应,所以说从架构本身上SpringMVC就容易实现restful url,而struts2的架构实现起来要费劲，因为Struts2中Action的一个方法可以对应一个url，而其类属性却被所有方法共享，这也就无法用注解或其他方式标识其所属方法了。


2、由上边原因，SpringMVC的方法之间基本上独立的，独享request response数据，请求数据通过参数获取，处理结果通过ModelMap交回给框架，方法之间不共享变量，而Struts2搞的就比较乱，虽然方法之间也是独立的，但其所有Action变量是共享的，这不会影响程序运行，却给我们编码 读程序时带来麻烦，每次来了请求就创建一个Action，一个Action对象对应一个request上下文。
3、由于Struts2需要针对每个request进行封装，把request，session等servlet生命周期的变量封装成一个一个Map，供给每个Action使用，并保证线程安全，所以在原则上，是比较耗费内存的。


4、 拦截器实现机制上，Struts2有以自己的interceptor机制，SpringMVC用的是独立的AOP方式，这样导致Struts2的配置文件量还是比SpringMVC大。


5、SpringMVC的入口是servlet，而Struts2是filter（这里要指出，filter和servlet是不同的。以前认为filter是servlet的一种特殊），这就导致了二者的机制不同，这里就牵涉到servlet和filter的区别了。


6、SpringMVC集成了Ajax，使用非常方便，只需一个注解@ResponseBody就可以实现，然后直接返回响应文本即可，而Struts2拦截器集成了Ajax，在Action中处理时一般必须安装插件或者自己写代码集成进去，使用起来也相对不方便。


7、SpringMVC验证支持JSR303，处理起来相对更加灵活方便，而Struts2验证比较繁琐，感觉太烦乱。


8、spring MVC和Spring是无缝的。从这个项目的管理和安全上也比Struts2高（当然Struts2也可以通过不同的目录结构和相关配置做到SpringMVC一样的效果，但是需要xml配置的地方不少）。


9、 设计思想上，Struts2更加符合OOP的编程思想， SpringMVC就比较谨慎，在servlet上扩展。


10、SpringMVC开发效率和性能高于Struts2。
11、SpringMVC可以认为已经100%零配置。


二、深入浅出Spring


    

  • Spring  IOC容器
    • 



　　　　　在Spring IOC容器中，有两个主要的容器系列：BeanFactory和ApplicationContext;BeanFactory它提供了最基本的IOC容器的功能，实例化对象、配置对象之间的依赖关系，在spring中，所有的对象都是由BeanFactory工厂来生厂管理的。ApplicationContext则提供了更多的面向企业级应用的功能，它是BeanFactory的子接口，拥有BeanFactory的所有功能；并提供了文本信息解析工具，提供了载入文件资源的通用方法，可以向注测为监听器的Bean发送事件。


    

  • spring依赖反转模式的理解
    • 



　　　　　什么的依赖反转，打个比方：我每次吃饭的时候都要买一双一次性筷子（每一次使用都要new一次），在这样的关系下，是”我“（即调用者）每次都要”主动“去买一次性筷子（另一个类），我对筷子说你老老实实的过来我的手上，是我控制了筷子，那好，在这种控制正转的关系下，放在现实生活当中，肯定是不现实的，而且人是懒惰的，他总会去创造出更加方便自己生活的想法，更确切的做法是，买一双普通的筷子（非一次性），把他放在一个容器当中（在Spring中叫做IOC容器），你需要使用的时候就对容器说：IOC我想要用筷子（向容器发出请求），接着筷子就会”注入“到的手上，而在这个过程当中，你不再是控制方，反而演变成一名请求者（虽然本身还是调用者），依赖于容器给予你资源，控制权坐落到了容器身上，于是这就是人们俗称的控制反转。——再理解为调用者应该依赖被调用者，而不是依赖于它的具体实现。　


　　　　　　如何来实现依赖反转模式，我可以用依赖注入，依赖注入有3种方式，分别为构造注入，设置注入，接口注入。


    

  1. 接口注入：
    2. 



在接口中定义要注入的信息，并通过接口来完成注入。（Spring不支持这种注入方式--不支持的原因是--Spring声称其是非入侵式的《离开这个框架也能活》，如果使用接口注入的话，就违背了这一原则），这里不做代码实现讲解。　


public interface  Computeable{
void inject(Printer p);
}

public class Computer  implements  Computeable{
Printer p;
public void inject(Printer p){

this.p=p;

}

}


2.构造器注入：


　　构造器注入方式，表示的是调用者在实例化的时候必须注入被调用者的实例，把上例改成构造器注入；


public class Computer {
  Printer p;
  public Computer(Printer p){
  this.p=p;
}  

}

Computer c=new Computer(new ColorPrinter());


　　3.setter注入：


　　setter注入方式，表示的是调用者通过设置一个全局属性并给设置set方法来注入；


public interface UserDao{
  addUser(String username);
}

public class UserDaoImpl implements UserDao{
    @Override
    public void addUser(String username)
{
    System.out.println("添加用户："+username);
}
}

public class UserMessage{    

    private UserDaoImpl userDao;    

    //使用设值方式赋值
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    public void addUser(String userName, String password) {    

        userDao.addUser(userName, password);
    }
}
　　
public class test{
  UserDao usedao =new UserDaoImpl();
  UserMessage userMessage=new UserMessage();
  userMessage.setUserDao(userdao);
}



    

  • ApplicationContext.xml文件的配置
    • 



　　　spring配置文件是用于指导Spring工厂进行Bean生产、依赖关系注入（装配）及Bean实例分发的"图纸"。Java EE程序员必须学会并灵活应用这份"图纸"准确地表达自己的"生产意图"。Spring配置文件是一个或多个标准的XML文档，applicationContext.xml是Spring的默认配置文件，当容器启动时找不到指定的配置文档时，将会尝试加载这个默认的配置文件。　


　　1.纯XML配置的Spring


<?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:context="http://www.springframework.org/schema/context"
        xmlns:jee="http://www.springframework.org/schema/jee"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
    <!-- 类似于财务部门一样，类就是钱，所有需要类的实例都由srping去管理 -->
    <bean id="myIndexAction" class="ssh.action.IndexAction" scope="prototype">
        <!-- setIs(myIndexService) -->
        <property name="is" ref="myIndexService"/>
    </bean>

    <!-- myIndexService = new ssh.service.IndexServiceImpl() -->
    <bean id="myIndexService" class="ssh.service.IndexServiceImpl" scope="prototype">
        <property name="id" ref="myIndexDao"/>
    </bean>

    <bean id="myIndexDao" class="ssh.dao.IndexDaoImpl" scope="prototype">
        <!-- 晚点再注入能用的seesionFactory -->
        <property name="sessionFactory"><null/></property>
    </bean>

</beans> 


　　　　纯的XML配置方式进一步降低了耦合，使得应用更加容易扩展，即使对配置文件进一步修改也不需要工程进行修改和重新编译。 
在处理大的业务量的时候，用XML配置应该更加好一些。因为XML更加清晰的表明了各个对象之间的关系，各个业务类之间的调用。同时spring的相关配置也能一目了然。 
 　　　　但它也有缺点：配置文件读取和解析需要花费一定的时间，配置文件过多的时候难以管理，无法对配置的正确性进行校验，增加了测试难度。


　　　2.使用注解的spring配置文件


在配置文件中加上注解解析器


<?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:context="http://www.springframework.org/schema/context"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.2.xsd
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-4.2.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd">
    <!-- 注解解析器 -->
    <context:component-scan base-package="包名"/>

</beans>


在各个JavaBean中加注解：


@Controller
@Scope("prototype")
public class MyNews6Action extends ActionSupport {
    @Autowired
    private MyNews6Service mns;


@Service
@Scope("prototype")
public class MyNews6ServiceImpl implements MyNews6Service {
    @Autowired
    private MyNews6Dao mnd;


@Repository
@Scope("prototype")
public class MyNews6DaoImpl implements MyNews6Dao {
    @Autowired　　private SessionFactory sf;


注解也有自己的优缺点；


优点有： 
1. 在class文件中，可以降低维护成本，annotation的配置机制很明显简单 
2. 不需要第三方的解析工具，利用java反射技术就可以完成任务 
3. 编辑期可以验证正确性，差错变得容易 
4. 提高开发效率


缺点有： 
1. 如果需要对于annotation进行修改，那么要重新编译整个工程 
2. 业务类之间的关系不如XML配置那样容易把握。 
3. 如果在程序中annotation比较多，直接影响代码质量，对于代码的简洁度有一定的影响。
				


				
时间： 2024-10-10 08:33:43 

		


		


	

	
	

		


		
深入浅出Struts2+Spring+Hibernate框架的相关文章


								

		

			

                SSH(Struts2+Spring+Hibernate)框架搭建流程&lt;注解的方式创建Bean&gt;
			

		

		

									

				此篇讲的是MyEclipse9工具提供的支持搭建自加包有代码也是相同:用户登录与注册的例子,表字段只有name,password. SSH,xml方式搭建文章链接地址:http://www.cnblogs.com/wkrbky/p/5912810.html 一.Hibernate(数据层)的搭建: 实现流程 二.Spring(注入实例)的使用: 实现流程 三.Struts2(MVC)的搭建: 实现流程 这里注意一点问题: Struts2与Hibernate在一起搭建,antlr包,有冲突.MyE			

		

	

				

		

			

                Struts2,Spring,Hibernate框架的优缺点
			

		

		

									

				Struts2,Spring,Hibernate框架的优缺点 Struts2框架(MVC框架)的优点如下: 1)  实现了MVC模式,层次结构清晰,使程序员只需关注业务逻辑的实现:        2)  丰富的标签库,大大提高了开发的效率:        3) Struts2提供丰富的拦截器实现        3) 通过配置文件,就可以掌握整个系统各个部分之间的关系:        4) 异常处理机制,只需在配置文件中配置异常的映射,即可对异常做相应的处理: Spring框架的优点如下: 1) 			

		

	

				

		

			

                SSH(Struts2+Spring+Hibernate)框架搭建流程
			

		

		

									

				添加支持 我先介绍的是MyEclipse9的自带框架支持搭建过程:(完全的步骤 傻瓜式的学习..~) 首先我们来搭建一个Web项目: 一.Hibernate(数据层)的搭建: 相关描述 Ⅰ.服务器与数据库之间的交互 Ⅱ. Hibernate封装了一系列的JDBC代码,提供相应的方法我们使用,使我们的开发变得简单快捷,效率大大提高 实现流程 二.Struts2(MVC)的搭建: 相关描述 Ⅰ.本质上相当于一个Servlet Ⅱ.不需要手动获取传递参数 (只需要定义声明属性名和设置get.set的方			

		

	

				

		

			

                Struts2 Spring Hibernate 框架整合  Annotation  MavenProject
			

		

		

									

				项目结构目录 pom.xml       添加和管理jar包 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.			

		

	

				

		

			

                Struts2+Spring+Hibernate 三大框架的合并集成
			

		

		

									

				这次来看看Struts2+Spring+Hibernate三大框架的整合应用,主要是Spring和Hibernate框架的整合,因为前边已经将Strtus2+Spring整合过了基本一样.  首先看一下分工吧: Struts2做的MVC的流程框架,主要完成从客户端访问到选择action的过程,其中过滤器起到了Controller的作用,action属于model,而jsp则是view页面的展示. Spring主要利用Ioc的特长来管理各种对象:action,service,dao,数据访问源,H			

		

	

				

		

			

                用MyEclipse搭建SSH框架(Struts2 Spring Hibernate)
			

		

		

									

				1.new一个web project. 2.右键项目,为项目添加Struts支持. 点击Finish.src目录下多了struts.xml配置文件. 3.使用MyEclipse DataBase Explorer建立数据源. new一个数据源.填入数据源信息. 点击test Driver,如果成功显示: 点击OK,点击Finish. 4.为项目添加Spring支持. 选择五个包,之后JAR Library Installation为如下图. 点击Next. 默认点击Finish. 5.为项目添加			

		

	

				

		

			

                SSH---集成Struts2+Spring+Hibernate（一）
			

		

		

									

				SSH---集成Struts2+Spring+Hibernate(一) 本方案让Spring创建Struts2的Action,不让Spring完全管理Struts2的Action,Struts2Action中的依赖对象,默认会根据名称自动装配 1.创建web项目 2.引入Struts2的依赖包,将依赖包拷贝到WEB-INF/lib下 *commons-logging-1.0.4.jar *freemarker-2.3.15.jar *ognl-2.7.3.jar * struts2-core-2			

		

	

				

		

			

                整合struts2+spring+hibernate
			

		

		

									

				 一.准备struts2+spring+hibernate所需要的jar包: 新建web项目并将jar包引入到工程项目中. 二.搭建struts2环境 a.在web项目的web.xml中加入struts2的过滤器,以过滤用户的所有请求,该过滤器将请求交给对应的Action处理 . <filter> <filter-name>Struts2</filter-name> <filter-class> org.apache.struts2.dispatcher			

		

	

				

		

			

                使用maven实现struts2 spring hibernate 的整合
			

		

		

									

				今天用maven实现了struts2 , spring, hibernate 的整合. 这中间出现了不少的错误.大都是因为配置文件出错引起的.在这里整合一下: 注:这里我们实现一个登陆功能.用户从jsp页面输入用户名和密码,服务器校验其正确性后,根据正确与否跳转到不同的页面. 一,整合之后的项目结构: 可以看到,与以前的“动态网站”项目的结构不同.Maven项目中所有的框架配置文件都放在了“resources”目录下面.在“resources”中的文件最终会被copy到项目的 WEB-INF/c