SpringMVC配置的基本步骤
使用Eclipse构建Maven的SpringMVC项目
使用Eclipse构建Maven的SpringMVC项目首先Eclipse需要安装Maven的插件,地址:/sites/m2e。
用MyEclipse安装Maven插件,建出的Maven项目有些问题。
一是,发布tomcat的时候resources总是不会被发布到tomcat下;二是,把WEB-INF下的classes改到target下的classes,但是不知道为什么MyEclipse要么仍然在WEB-INF下生成class。
要么真不在WEB-INF生成classes 了但是发布tomcat的时候,class文件一个都不会给你发布过去,超级郁闷。
但是使用Eclipse构建Maven项目后,使用MyEclipse打开就没问题了。
用maven的好处:我感觉最主要就是自动下载jar包和它所依赖的包,这样可以保证了多人开发时jar版本不同的问题。
再就是文件结构清晰,java文件,资源文件,测试文件都分的很清楚。
将介绍两种方法:一,直接建立Maven项目方法;二、建立Dynamic Web project转成Maven 项目方法。
1,建立Maven项目接下来使用Eclipse的maven构建一个web项目,以构建SpringMVC项目为例:1.1 选择建立Maven Project选择File -> New -> Other,在New窗口中选择Maven -> Maven Project。
点击newxt。
1.2 选择项目路径Use default Workspace location默认工作空间。
1.3 选择项目类型在Artifact Id中选择maven-archetype-webapp1.4 输入Group ID和Artifact ID,以及PackageGroup ID一般写大项目名称。
Artifact ID是子项目名称。
例如Spring的web包,Group ID:org.springframework,artifactId:spring-web。
SpringMVC使用MultipartFile文件上传配置,多文件上传
SpringMVC使用MultipartFile文件上传配置,多文件上传,.基本的SpringMVC的搭建在我的上一篇文章里已经写过了,这篇文章主要说明一下如何使用SpringMVC进行表单上的文件上传以及多个文件同时上传的步骤一、配置文件:SpringMVC 用的是的MultipartFile来进行文件上传所以我们首先要配置MultipartResolver:用于处理表单中的file1.<!-- 配置MultipartResolver 用于文件上传使用spring的CommosMultipartResolver -->2.<beans:bean id="multipartResolver"class="org.springframework.web.multipmonsMultipartResolver"3.p:defaultEncoding="UTF-8"4.p:maxUploadSize="5400000"5.p:uploadTempDir="fileUpload/temp"6.>7.</beans:bean>其中属性详解:defaultEncoding="UTF-8"是请求的编码格式,默认为iso-8859-1maxUploadSize="5400000"是上传文件的大小,单位为字节uploadTempDir="fileUpload/temp"为上传文件的临时路径二、创建一个简单的上传表单:1.<body>2.<h2>文件上传实例</h2>3.4.5.<form action="fileUpload.html"method="post"enctype="multipart/form-data">6.选择文件:<input type="file"name="file">7.<input type="submit"value="提交">8.</form>9.10.11.</body>注意要在form标签中加上enctype="multipart/form-data"表示该表单是要处理文件的,这是最基本的东西,很多人会忘记然而当上传出错后则去找程序的错误,却忘了这一点三、编写上传控制类1、创建一个控制类: FileUploadController和一个返回结果的页面list.jsp2、编写提交表单的action:1.//通过Spring的autowired注解获取spring默认配置的request2.@Autowired3.private HttpServletRequest request;4.5./***6. * 上传文件用@RequestParam注解来指定表单上的file为MultipartFile7. *8. * @param file9. * @return10. */11.@RequestMapping("fileUpload")12.public String fileUpload(@RequestParam("file") MultipartFile file) {13.// 判断文件是否为空14.if (!file.isEmpty()) {15.try {16.// 文件保存路径17. String filePath = request.getSession().getServletContext().getRealPath("/") + "upload/"18. + file.getOriginalFilename();19.// 转存文件20. file.transferTo(new File(filePath));21. } catch (Exception e) {22. e.printStackTrace();23. }24. }25.// 重定向26.return"redirect:/list.html";27. }28.29./***30. * 读取上传文件中得所有文件并返回31. *32. * @return33. */34.@RequestMapping("list")35.public ModelAndView list() {36. String filePath = request.getSession().getServletContext().getRealPath("/") + "upload/";37. ModelAndView mav = new ModelAndView("list");38. File uploadDest = new File(filePath);39. String[] fileNames = uploadDest.list();40.for (int i = 0; i < fileNames.length; i++) {41.//打印出文件名42. System.out.println(fileNames[i]);43. }44.return mav;45. }3、使用SpringMVC注解RequestParam来指定表单中的file参数;4、指定一个用于保存文件的web项目路径5、通过MultipartFile的transferTo(File dest)这个方法来转存文件到指定的路径。
spring MVC原理及配置
spring MVC原理及配置springmvc原理及配置springmvc原理及配置1.springmvc详述:springmvc就是spring提供更多的一个强悍而有效率的web框架。
借助注释,springmvc提供更多了几乎就是pojo的研发模式,使控制器的研发和测试更加直观。
这些控制器通常不轻易处置命令,而是将其委托给spring上下文中的其他bean,通过spring的倚赖转化成功能,这些bean被转化成至控制器中。
springmvc主要由dispatcherservlet、处理器映射、处理器(控制器)、视图解析器、视图组成。
他的两个核心是两个核心:处理器映射:选择使用哪个控制器来处理请求视图解析器:选择结果应该如何渲染通过以上两点,springmvc确保了如何挑选掌控处置命令和如何挑选视图展现出输入之间的松耦合。
2.springmvc运行原理这里写图片描述(2)找寻处理器:由dispatcherservlet控制器查阅一个或多个handlermapping,找出处置命令的controller。
(3)调用处理器:dispatcherservlet将请求提交到controller。
(4)(5)调用业务处置和回到结果:controller调用业务逻辑处置后,回到modelandview。
3.springmvc接口解释(1)dispatcherservlet接口:spring提供的前端控制器,所有的请求都有经过它来统一分发。
在dispatcherservlet将请求分发给springcontroller 之前,需要借助于spring提供的handlermapping定位到具体的controller。
(2)handlermappingUSB:能够完成客户请求到controller映射。
(3)controller接口:须要为mammalian用户处置上述命令,因此同时实现controllerUSB时,必须确保线程安全并且可以器重。
最全最经典spring_mvc教程
spring mvc学习教程(一)-入门实例引言1.MVC:Model-View-Control框架性质的C层要完成的主要工作:封装web请求为一个数据对象、调用业务逻辑层来处理数据对象、返回处理数据结果及相应的视图给用户。
2.简要概述springmvcSpring C 层框架的核心是DispatcherServlet,它的作用是将请求分发给不同的后端处理器,也即使用了一种被称为Front Controller 的模式(后面对此模式有简要说明)。
Spring 的C 层框架使用了后端控制器来、映射处理器和视图解析器来共同完成C 层框架的主要工作。
并且spring 的C 层框架还真正地把业务层处理的数据结果和相应的视图拼成一个对象,即我们后面会经常用到的ModelAndView 对象。
一、入门实例1. 搭建环境在spring的官方API文档中,给出所有包的作用概述,现列举常用的包及相关作用:org.springframework.aop-3.0.5.RELEASE.jar:与Aop编程相关的包org.springframework.beans-3.0.5.RELEASE.jar:提供了简捷操作bean的接口org.springframework.context-3.0.5.RELEASE.jar:构建在beans包基础上,用来处理资源文件及国际化。
org.springframework.core-3.0.5.RELEASE.jar:spring核心包org.springframework.web-3.0.5.RELEASE.jar:web核心包,提供了web层接口org.springframework.web.servlet-3.0.5.RELEASE.jar:web 层的一个具体实包,DispatcherServlet也位于此包中。
后文全部在spring3.0 版本中进行,为了方便,建议在搭建环境中导入spring3.0 的所有jar 包(所有jar 包位于dist 目录下)。
Spring MVC 简明教程
Spring框架从创建伊始就致力于为复杂问题提供强大的、非侵入性的解决方案。
Spring 2.0当中为缩减XML配置文件数量引入定制命名空间功能,从此它便深深植根于核心Spring框架(aop、context、jee、jms、 lang、tx和util命名空间)、Spring Portfolio项目(例如Spring Security)和非Spring项目中(例如CXF)。
Spring 2.5推出了一整套注解,作为基于XML的配置的替换方案。
注解可用于Spring管理对象的自动发现、依赖注入、生命周期方法、Web层配置和单元/集成测试。
探索Spring 2.5中引入的注解技术系列文章由三部分组成,本文是其中的第二篇,它主要讲述了Web层中的注解支持。
最后一篇文章将着重介绍可用于集成和测试的其它特性。
这个系列文章的第一部分论述了Java注解(annotation)是如何代替XML来配置Spring管理对象和依赖注入的。
我们再用一个例子回顾一下:@Controllerpublic class ClinicController {private final Clinic clinic;@Autowiredpublic ClinicController(Clinic clinic) {this.clinic = clinic;}...@Controller表明ClinicController是Web层组件,@Autowired请求一个被依赖注入的Clinic实例。
这个例子只需要少量的XML语句就能使容器识别两个注解,并限定组件的扫描范围:<context:component-scanbase-package="org.springframework.samples.petclinic"/>这对Web层可谓是个福音,因为在这层Spring的XML配置文件已日益臃肿,甚至可能还不如层下的配置来得有用。
springmvc框架搭建之xml配置说明(spring4+hibernate4)
SpringMVC框架搭建说明Spring4.1.4 + hibernate4.3.81、web.xml配置程序运行时从web.xml开始,加载顺序为:context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet如下为web.xml的配置说明<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="/2001/XMLSchema-instance"xmlns="/xml/ns/javaee"xmlns:web="/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5"><!—-显示项目名称--><display-name>bmymis2</display-name><!-- 指定配置文件位置,contextConfigLocation是ContextLoaderListener中的一个参数,通过该参数在ContextLoaderListener中加载applicationContext-*.xml,并装配ApplicationContext --> <context-param><param-name>contextConfigLocation</param-name><param-value>classpath:applicationContext-*.xml</param-value></context-param><!-- 定义SPRING监听器,启动Web容器时,自动装配ApplicationContext的配置信息--><listener><listener-class>org.springframework.web.context.ContextLoaderListener </listener-class></listener><!—-字符编码过滤器,解决中文乱码问题--><filter><filter-name>encodingFilter</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><!—- springmvc配置--><servlet><servlet-name>springServlet</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet </servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath*:/spring-mvc.xml</param-value></init-param><load-on-startup>1</load-on-startup> //容器启动时首先初始化该servlet </servlet><servlet-mapping><servlet-name>springServlet</servlet-name><url-pattern>/</url-pattern> //表示所有页面都由springmvc处理</servlet-mapping><!—-浏览器输入到项目名,默认打开如下配置页面--><welcome-file-list><welcome-file>/web/login.jsp</welcome-file></welcome-file-list><!—-错误跳转页面--><error-page><error-code>404</error-code><location>/404.html</location></error-page></web-app>2、applicationContext-common.xml配置:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-4.0.xsd/schema/context/schema/context/spring-context-4.0.xsd/schema/aop/schema/aop/spring-aop-4.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><!-- 加载资源文件其中包含变量信息,必须在Spring配置文件的最前面加载,即第一个加载--><context:property-placeholder location="classpath:application.properties"/><!—-扫描包路径选项,使用annotation 自动注册bean,并保证@Required,@Autowired的属性被注入,有了该配置,那么<context:annotation-config/>这个配置就可以省略(以下配置包含了<context:annotation-config/>配置)--><context:component-scan base-package="xxx.xxx.xxx"/><!-- 数据源配置,使用应用内的DBCP数据库连接池 --><bean id="dataSource" class="mons.dbcp.BasicDataSource"destroy-method="close"><!-- 定义数据库连接池数据源bean destroy-method="close"的作用是当数据库连接不使用的时候,就把该连接重新放到数据池中,方便下次使用调用--><property name="driverClassName" value="${jdbc.driverClassName}"/><property name="url" value="${jdbc.url}"/><property name="username" value="${ername}"/><property name="password" value="${jdbc.password}"/></bean><!—Hibernate的注解配置 --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties"><props><prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop><prop key="hibernate.dialect">${hibernate.dialect}</prop><prop key="hibernate.show_sql">${hibernate.show_sql}</prop></props></property><property name="packagesToScan" value="xxx.xxx.xxx.model" /></bean><!-- 配置Hibernate事务管理器 --><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/></bean><!-- 配置事务异常封装 --><bean id="persistenceExceptionTranslationPostProcessor"class="org.springframework.dao.annotation.PersistenceExceptionTranslationPost Processor"/><!-- 声明式容器事务管理 ,transaction-manager指定事务管理器为transactionManager --> <tx:advice id="txAdvice" transaction-manager="transactionManager"><tx:attributes><tx:method name="add*" propagation="REQUIRED"/><tx:method name="get*" propagation="REQUIRED"/><tx:method name="*" read-only="true"/></tx:attributes></tx:advice><aop:config expose-proxy="true"><!-- 只对业务逻辑层实施事务 --><aop:pointcut id="txPointcut"expression="execution(*xxx.xxx.xxx.service..*.*(..))"/><!-- Advisor定义,切入点和通知分别为txPointcut、txAdvice --><aop:advisor pointcut-ref="txPointcut" advice-ref="txAdvice"/> </aop:config></beans>3、application.properties配置jdbc.driverClassName=org.postgresql.Driverjdbc.url=jdbc:postgresql://ip:5432/数据库名ername=postgresjdbc.password=123hibernate.dialect=org.hibernate.dialect.PostgreSQLDialecthibernate.show_sql=truehibernate.format_sql=false4、spring-mvc.xml配置<?xml version="1.0"encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:xsi="/2001/XMLSchema-instance"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/tx/schema/tx/spring-tx-4.0.xsd"><!-- 启用spring mvc 注解 --><mvc:annotation-driven><!-- 自动扫描且只扫描@Controller --><context:component-scan base-package="xxx.xxx.xxx "use-default-filters="false"></context:component-scan><!-- 定义JSP文件的位置 --><beanclass="org.springframework.web.servlet.view.InternalResourceView Resolver"><property name="prefix"value="/jsp/"/><property name="suffix"value=".jsp"/></bean><!-- 容器默认的DefaultServletHandler处理所有静态内容与无RequestMapping处理的URL--> <mvc:default-servlet-handler/><!-- 定义无需Controller的url<->view直接映射 --><mvc:view-controller path="/"view-name="login"/></beans>。
SpringMVC框架搭建流程(完整详细版)
SpringMVC框架搭建流程(完整详细版)SpringMVC框架搭建流程开发过程1)配置DispatcherServlet前端控制器2)开发处理具体业务逻辑的Handler(@Controller、 @RequestMapping)3) xml配置⽂件配置controller扫描,配置springmvc三⼤件4)将xml⽂件路径告诉springmvc(DispatcherServlet)详细流程:创建⽬录新建maven项⽬,注意选择webapp⾻架。
创建成功之后会发现没有src等⽬录,这些需要我们⼿动创建:在src下⾯新建main,main下⾯新建java⽬录,选择java⽬录,右键,在main下⾯继续新建resource⽬录,选择resource⽬录,右键,pom.xmlpom.xml<?xml version="1.0" encoding="UTF-8"?><project xmlns="/POM/4.0.0"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/POM/4.0.0 /xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion><groupId></groupId><artifactId>springmvc-demo</artifactId><version>1.0-SNAPSHOT</version><packaging>war</packaging><properties><project.build.sourceEncoding>UTF-8</project.build.sourceEncoding><piler.source>11</piler.source><piler.target>11</piler.target></properties><dependencies><!--引⼊spring webmvc的依赖--><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.1.12.RELEASE</version></dependency></dependencies><build><plugins><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><version>2.2</version><configuration><port>8080</port><path>/</path></configuration></plugin></plugins></build></project>注意Tomcat7插件是⽤来运⾏项⽬的,右侧运⾏:springmvc相关配置main⽂件夹下⾯新建webapp⽂件夹,webapp下⾯新建WEB-INF,下⾯新建web.xml<!DOCTYPE web-app PUBLIC"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN""/dtd/web-app_2_3.dtd" ><web-app><display-name>Archetype Created Web Application</display-name><servlet><servlet-name>springmvc</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>classpath:springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>springmvc</servlet-name><!--⽅式⼀:带后缀,⽐如*.action *.do *.aaa该种⽅式⽐较精确、⽅便,在以前和现在企业中都有很⼤的使⽤⽐例⽅式⼆:/ 不会拦截 .jsp,但是会拦截.html等静态资源(静态资源:除了servlet和jsp之外的js、css、png等)为什么配置为/ 会拦截静态资源因为tomcat容器中有⼀个web.xml(⽗),你的项⽬中也有⼀个web.xml(⼦),是⼀个继承关系⽗web.xml中有⼀个DefaultServlet, url-pattern 是⼀个 /此时我们⾃⼰的web.xml中也配置了⼀个 / ,覆写了⽗web.xml的配置为什么不拦截.jsp呢?因为⽗web.xml中有⼀个JspServlet,这个servlet拦截.jsp⽂件,⽽我们并没有覆写这个配置,所以springmvc此时不拦截jsp,jsp的处理交给了tomcat如何解决/拦截静态资源这件事?⽅式三:/* 拦截所有,包括.jsp--><!--拦截匹配规则的url请求,进⼊springmvc框架处理--><url-pattern>/</url-pattern></servlet-mapping></web-app>⾥⾯配置了springmvc相关的配置,引⼊了springmvc.xml:在resource⽬录下新建springmvc.xml:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:mvc="/schema/mvc"xsi:schemaLocation="/schema/beanshttps:///schema/beans/spring-beans.xsd/schema/contexthttps:///schema/context/spring-context.xsd/schema/mvchttps:///schema/mvc/spring-mvc.xsd"><!--开启controller扫描--><context:component-scan base-package=".controller"/><!--配置springmvc的视图解析器--><bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/"/><property name="suffix" value=".jsp"/></bean><!--⾃动注册最合适的处理器映射器,处理器适配器(调⽤handler⽅法)--><mvc:annotation-driven/></beans>在java⽬录下新建包.controller,下⾯新建DemoController:package .controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.servlet.ModelAndView;import java.util.Date;/*** @author lyj* @Title: DemoController* @ProjectName springmvc-demo* @Description: TODO* @date 2020/6/9 21:21*/@Controller@RequestMapping("/demo")public class DemoController {/*** http://localhost:8080/demo/handle01*/@RequestMapping("/handle01")public ModelAndView handle01(){Date date=new Date();ModelAndView modelAndView=new ModelAndView();modelAndView.addObject("date",date);modelAndView.setViewName("success");return modelAndView;}}在WEB-INF下⾯新建jsp⽂件夹,下⾯新建success.jsp:<%@ page language="java" isELIgnored="false" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%> <html lang="en"><head><meta charset="UTF-8"><title>Title</title></head><body>当前时间 ${date}</body></html>完毕后整个项⽬结构如下:测试:浏览器访问:。
SpringMVC体系结构和处理请求控制器
SpringMVC体系结构和处理请求控制器MVC设计模式 通常的Web项⽬,架构模式基本分层 数据库访问接⼝:DAO层 处理业务逻辑:Service层 数据实体:POJO 负责前端请求的接受处理:Servlet 负责前端页⾯展⽰:JSP MVC设计模式:它是软件⼯程中的⼀种软件架构模式。
它强制性地使软件系统的输⼊、处理和输出分开。
把软件系统分为三个基本部分:模型(Model)、视图(View)、控制器(Controller) 视图(View):负责格式化数据并把他们呈现给⽤户,包括数据展⽰、⽤户交互、数据验证、界⾯设计等功能。
对应组件:JSP或者HTML⽂件 控制器(Controller):负责接收并转发请求,对进⾏处理后指派视图并将响应结果发送给客户端。
对应组件Servlet 模型(Model):模型对象拥有最多的处理任务,是应⽤程序的主体部分,负责数据逻辑(业务规则)的处理和实现数据操作。
对应组件:JavaBean(处理业务逻辑Service层,数据库操作相关的DAO层,贯穿各层之间的数据模型,数据实体POJO) MVC的两种模式 (1)JSP Model1 业务流程较为简单时,可以把控制器的功能交给视图实现。
故Model1模式只有视图和模型,没有控制器(JSP+JavaBean) 浏览器 - 请求 - JSP - JavaBean - 数据库 - JavaBean - JSP -响应 - 浏览器 (2) JSP Model2 相⽐JSPModel1,业务流程复杂时,就需要把业务流程控制交给控制器来实现。
即(JSP+Servlet+JavaBean) 浏览器 - 请求 - Servlet - JavaBean- JSP - 数据库 - JavaBean - JSP -Servlet -响应 - 浏览器 MVC处理过程 MVC的整体结构,对于MVC三个部分(模型、视图、控制器)功能职责分别进⾏了相应的阐述 (1)⾸先视图提供系统与⽤户交互的界⾯,并发送⽤户输⼊给控制器 (2)控制器接收⽤户的请求,并决定应该调⽤哪个模型来进⾏处理 (3)模型根据⽤户请求进⾏相应的业务逻辑处理,并返回处理结果(数据) (4)控制器根据返回的处理结果,调⽤相应的视图格式化模型返回的数据,并通过视图呈现给⽤户结果 MVC优缺点1. 优点1. 多视图共享⼀个模型,⼤⼤提⾼代码的可重⽤性2. MVC三个模块相互独⽴,松耦合架构3. 控制器提⾼了应⽤程序的灵活性和可配置性4. 有利于软件⼯程化管理 通过MVC的设计模式最终可以打造出⼀个松耦合+⾼重⽤性+⾼可适⽤性的架构 2.缺点1. 原理复杂2. 增加了系统结构和实现的复杂性3. 视图对模型数据的低效率访问 MVC来说:并不适合⼩型甚⾄中型规模的项⽬,花费⼤量时间将MVC应⽤到规模并不是很⼤的应⽤程序通常得不偿失Spring MVC介绍及其环境搭建 Spring MVC框架介绍 Spring MVC是Spring框架中⽤于Web应⽤开发的⼀个模块,是Spring提供的⼀个基于MVC设计式的优秀Web开发框架,本质上相当于Servlet。
SpringMVC目录结构配置
SpringMVC目录结构配置SpringMVC是一种常见的Java Web框架,它遵循MVC(Model-View-Controller)设计模式,用于构建灵活可扩展的Web应用程序。
SpringMVC的目录结构对于项目的开发和维护非常重要,下面会详细介绍SpringMVC的标准目录结构以及配置方式。
1.标准目录结构1.1 src/main/java:主要用于存放Java源代码。
1.2 src/main/resources:主要用于存放配置文件和资源文件。
1.3 src/main/webapp:主要用于存放Web应用的静态资源。
1.4 src/test/java:主要用于存放测试用例的Java源代码。
1.5 src/test/resources:主要用于存放测试用例的配置文件和资源文件。
2.详细解析2.1 src/main/java目录src/main/java目录是存放Java源代码的默认目录,它包括以下几个子目录:- config:用于存放Spring配置类,如配置数据库连接、配置事务管理等。
- interceptor:用于存放SpringMVC的拦截器。
- model:用于存放数据模型相关的实体类。
- util:用于存放工具类。
- web:用于存放SpringMVC的控制器。
2.2 src/main/resources目录src/main/resources目录是存放配置文件和资源文件的默认目录,它包括以下几个子目录:- static:用于存放静态资源文件,如CSS、JavaScript、图片等。
- templates:用于存放模板文件,如HTML、Thymeleaf模板等。
- application.properties:存放项目的配置信息,如数据库配置、端口配置等。
- logback.xml:存放日志配置,如日志级别、输出路径等。
- mapper:存放MyBatis的Mapper.xml文件。
SpringMVC+Spring+Mybatis框架配置详细步骤(eclipse普通版)
SSI框架搭建SpringMVC3.1.2+Spring3.1.2+Mybatis3.2.6编号:SSI-SMVC3-S3-I3版本:V1.0级别:公开编写时间:2016-02-17目录1 导言 (1)1.1 目的 (1)1.2 范围 (1)1.3 说明 (1)2 搭建SpringMVC (2)2.1 搭建所需jar包 (2)2.2 其他依赖包 (3)2.3 搭建步骤 (4)2.3.1 创建项目 (4)2.3.2 导入jar包 (6)2.3.3 配置web.xml (7)2.3.4 配置spring-servlet.xml (9)2.3.5 配置applicationContext.xml (10)2.3.6 配置log4j.properties (10)3 整合mybatis (11)3.1 整合所需jar包 (11)3.2 其他依赖包 (11)3.3 整合步骤 (11)3.3.1 导入jar包 (11)3.3.2 配置config.properties (12)3.3.3 配置spring-dataSource.xml (12)3.3.4 配置applicationContext.xml (15)3.3.5 配置mybatis-config.xml (16)3.3.6 创建实体model (17)3.3.7 创建实例化dao (19)3.3.8 创建业务服务service (21)3.3.9 创建控制层controller (23)3.3.10 页面代码 (28)3.3.11 启动项目 (37)1导言1.1 目的本文档是根据个人的工作经验搭建的轻量级SSI框架,也是实际应用中比较全面的基础框架,用于指导SSI框架初学者学习搭建SSI框架,希望能给各位使用者提供帮助,同时也希望朋友们尽量去帮助其他人。
1.2 范围本次框架搭建的版本是SpringMVC3.1.2+Spring3.1.2+Mybatis3.2.6,数据库采用的是mysql,在eclipse开发工具下搭建直接搭建的web项目,页面采用的是h5,ajax实现数据访问,如果页面为jsp等,则修改controller的返回类型即可。
ssm框架流程
ssm框架流程SSM框架(Spring+SpringMVC+MyBatis)是目前非常流行的Java Web开发框架,它结合了Spring框架、SpringMVC框架和MyBatis框架的优势,使得开发者可以更加高效地进行Web应用开发。
SSM框架的流程分为前端请求处理、后端分发处理和数据库操作三个步骤。
第一步是前端请求处理,当用户在浏览器中输入URL或者点击页面的链接时,请求会发送到服务器端。
SpringMVC框架的核心是DispatcherServlet,它是前端控制器,负责接收所有请求,并进行第一步的处理。
DispatcherServlet会根据请求的URL找到对应的处理器(Controller),并将请求数据封装成一个包含请求信息的对象。
Controller中的处理方法会处理该请求,并将处理结果封装成一个Model对象,并返回视图名。
第二步是后端分发处理,DispatcherServlet会将Model对象传递给ViewResolver(视图解析器),ViewResolver根据视图名找到对应的视图模板(JSP、HTML等),并将Model对象中的数据填充到视图模板中。
最终,服务器会将填充好数据的视图返回给用户的浏览器。
第三步是数据库操作,MyBatis框架是SSM框架中负责数据库操作的核心组件。
在Controller中,可以通过@Autowired注解注入MyBatis的Mapper接口,并调用接口中定义的方法来实现对数据库的操作。
Mapper接口中定义了增删改查等操作数据库的方法,而对应的SQL语句则是在MyBatis的XML文件中配置的。
MyBatis会读取XML文件,并根据接口方法的名称和参数类型来执行对应的SQL语句,最终将结果返回给Controller。
在整个流程中,Spring框架扮演了框架的骨架角色,它负责依赖注入、事务管理等底层功能。
SpringMVC框架实现了前端请求处理和后端分发处理的功能,它通过DispatcherServlet来接收和分发请求,并将处理结果返回给浏览器。
srping mvc配置及相关跳转控制说明
当url为“person.do?do=toEditPage”时程序的走向:1,程序会根据后面的person.do后面的do转入spring的控制器<servlet><servlet-name> appfuse</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name> appfuse</servlet-name><url-pattern>*.do</url-pattern> //处理以什么方式结尾的动作</servlet-mapping>2,根据appfuse 找到appfuse-servlel.xml 。
这个是spring mvc非常重要的配置文件。
注明了每一次跳转动作进入的控制器,注入相应的dao层,业务层,以及commond层程序会根据/person.do 找到相应的控制器:com.nbw.test.web.action.PersonController。
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"id="viewResolver"><property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/><property name="prefix" value="/WEB-INF/jsp/"/> //这个是跳转页面的路径<property name="suffix" value=".jsp"/> //指定跳转路径下以什么结尾的文件</bean><beanclass="org.springframework.web.servlet.mvc.multiaction.ParameterMethodNameResolve r" id="paramResolver"><property name="paramName" value="do"/> //这个在指定当控制器有多方法的时候,使用什么样的参数名来获得方法例如:person.do?do=toEditPage</bean>//下面当url为person.do的时候请求进入PersonController控制器。
springMVC配置(XML配置详解)
springMVC配置(XML配置详解)原⽂出⾃:web.xml配置:servlet><servlet-name>dispatcher</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><description>加载/WEB-INF/spring-mvc/⽬录下的所有XML作为Spring MVC的配置⽂件</description><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring-mvc/*.xml</param-value></init-param><load-on-startup>1</load-on-startup></servlet><servlet-mapping><servlet-name>dispatcher</servlet-name><url-pattern>*.htm</url-pattern></servlet-mapping>这样,所有的.htm的请求,都会被DispatcherServlet处理;初始化 DispatcherServlet 时,该框架在 web 应⽤程序WEB-INF ⽬录中寻找⼀个名为[servlet-名称]-servlet.xml的⽂件,并在那⾥定义相关的Beans,重写在全局中定义的任何Beans,像上⾯的web.xml中的代码,对应的是dispatcher-servlet.xml;当然也可以使⽤<init-param>元素,⼿动指定配置⽂件的路径;dispatcher-servlet.xml 配置:<?xml version="1.0" encoding="UTF-8"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:mvc="/schema/mvc"xmlns:p="/schema/p"xmlns:context="/schema/context"xmlns:aop="/schema/aop"xmlns:tx="/schema/tx"xsi:schemaLocation="/schema/beans/schema/beans/spring-beans-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd/schema/aop/schema/aop/spring-aop-3.0.xsd/schema/tx/schema/tx/spring-tx-3.0.xsd/schema/mvc/schema/mvc/spring-mvc-3.0.xsd/schema/context/schema/context/spring-context-3.0.xsd"><!--使Spring⽀持⾃动检测组件,如注解的Controller--><context:component-scan base-package="com.minx.crm.web.controller"/><bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver"p:prefix="/WEB-INF/jsp/"p:suffix=".jsp" /></beans>第⼀个Controller:package com.minx.crm.web.controller;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;@Controllerpublic class IndexController {@RequestMapping("/index")public String index() {return "index";}}@Controller注解标识⼀个控制器,@RequestMapping注解标记⼀个访问的路径(/index.htm),return "index"标记返回视图(index.jsp);注:如果@RequestMapping注解在类级别上,则表⽰⼀相对路径,在⽅法级别上,则标记访问的路径;从@RequestMapping注解标记的访问路径中获取参数:Spring MVC ⽀持RESTful风格的URL参数,如:@Controllerpublic class IndexController {@RequestMapping("/index/{username}")public String index(@PathVariable("username") String username) {System.out.print(username);return "index";}}在@RequestMapping中定义访问页⾯的URL模版,使⽤{}传⼊页⾯参数,使⽤@PathVariable 获取传⼊参数,即可通过地址:http://localhost:8080/crm/index/tanqimin.htm 访问;根据不同的Web请求⽅法,映射到不同的处理⽅法:使⽤登陆页⾯作⽰例,定义两个⽅法分辨对使⽤GET请求和使⽤POST请求访问login.htm时的响应。
mvc的处理流程
mvc的处理流程MVC是一种软件设计模式,它将应用程序分成三个主要组件:模型,视图和控制器。
MVC的设计目的是将应用程序解耦,简化开发和维护。
MVC的处理流程如下:1. 用户发送请求用户在浏览器中输入URL地址,发送请求给服务器。
这个请求就是一个HTTP请求,包含一个请求头和请求体。
2. 路由分发请求路由分发器(Dispatcher)负责接收HTTP请求,并将请求分发给相应的控制器。
路由分发器使用路由器(Router)来解析URL,并决定使用哪个控制器来处理请求。
3. 控制器处理请求控制器是MVC中的中心点,负责处理请求并返回响应。
控制器使用模型来读取或修改数据,使用视图来生成响应。
控制器还可以处理表单提交、数据验证和错误处理等任务。
4. 模型读取或修改数据模型是应用程序中的数据层,负责读取或修改数据库中的数据。
控制器可以使用模型来读取数据、插入数据、更新数据或删除数据。
模型将操作结果返回给控制器,并由控制器决定如何处理结果。
5. 视图生成响应视图负责生成响应。
视图使用模板引擎来渲染模板并生成HTML代码,然后将HTML代码发送给浏览器。
视图可以显示模型中的数据、处理表单数据、显示错误信息等。
6. 响应发送给浏览器当视图生成HTML代码后,控制器将响应发送回浏览器。
响应包括HTTP响应头和响应体。
HTTP响应头包含状态码、内容类型、字符集等信息,响应体包含HTML代码。
7. 浏览器渲染页面浏览器将HTML代码解析为DOM树,并使用CSS样式来渲染页面。
用户可以与页面进行交互,例如输入数据、点击链接、提交表单等。
8. 页面发出新请求页面可能会发出新请求,例如点击链接或提交表单。
这会触发MVC的处理流程,直到浏览器最终渲染页面并显示结果。
springMVC配置文件详解
web.xml的配置web.xml应该是整个项目最重要的配置文件了,不过servlet3.0中已经支持注解配置方式了。
在servlet3.0以前每个servlet必须要在web.xml中配置servlet及其映射关系。
但是在spring框架中就不用了,因为Spring中是依赖注入(Dependency Injection)的也叫控制反转(Inversion of Control)。
但是也要配置一个重要的servlet,就是前端控制器(DispatcherServlet)。
配置方式与普通的servlet基本相似。
配置内容如下:<!-- 配置前端控制器--><servlet><servlet-name>spring</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><!-- ContextconfigLocation配置springmvc加载的配置文件适配器、处理映射器等--><param-name>contextConfigLocation</param-name><param-value>WEB-INF/classes/spring/springmvc.xml</param-value></init-param></servlet><servlet-mapping><servlet-name>spring</servlet-name><!-- 1、.action访问以.action结尾的由DispatcherServlet进行解析2、/,所有访问都由DispatcherServlet进行解析--><url-pattern>/</url-pattern></servlet-mapping>这里需要注意,springmvc.xml是spring配置文件,将在后面讨论。
springmvc拦截器(定义、配置以及执行流程)
springmvc拦截器(定义、配置以及执⾏流程)⼀、拦截器概念springmvc中的拦截器(interceptor)类似于Servlet中的过滤器(Filter),它主要⽤于拦截⽤户请求并做相应的处理。
在实际项⽬中会经常使⽤到拦截器,例如在购物⽹站中通过拦截器可以拦截未登录的⽤户,禁⽌其购买商品,或者使⽤它来验证已登录⽤户是否有相应的操作权限(即权限验证),记录请求信息的⽇志等应⽤。
所谓拦截器,就是能够在进⾏某个操作之前拦截请求,如果请求符合条件就允许在往下执⾏。
⽐如说,海关就是⼀个拦截器,他拦截进出⼝的货物,如果货物满⾜进出⼝条件,则放⾏,否则就拦截,退回处理。
⼆、拦截器定义和配置使⽤在springmvc中要使⽤拦截器,就需要对拦截器类进⾏定义和配置,通常拦截器类可以通过两种⽅式来定义。
第⼀种通过实现HandleInterceptor接⼝,或者继承HandleInterceptor接⼝的实现类HandleInterceptorAdapter来定义;第⼆种通过实现WebRequestInterceptor接⼝,或继承WebRequestInterceptor接⼝的实现类来定义。
1、拦截器的定义:以实现HandleInterceptor接⼝为例public class LoginInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//做⼀些操作⽅法返回类型为布尔值return false;}@Overridepublic void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {//做⼀些操作}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {//做⼀些操作}}从以上可以看出,⾃定义的拦截器类实现了HandlerInterceptor接⼝,并且实现了接⼝中的三个⽅法。
Eclipse使用maven搭建springmvc图文教程
Eclipse使⽤maven搭建springmvc图⽂教程本⽂为⼤家介绍了Eclipse使⽤maven搭建spring mvc的详细步骤,供⼤家参考,具体内容如下1、环境配置a). Java 1.7b). Eclipse lunac). Maven3.2.5d). Spring 4.1.42、创建maven⼯程a). 打开eclipse,file->new->project->Maven->Maven Projectb). 下⼀步c). 选择创建的⼯程为webapp,下⼀步d). 填写项⽬的group id和artifact id。
⼀般情况下,group id写域名的倒序,artifact id写项⽬名称即可。
最后点完成。
e). 最初建好后,项⽬⽬录结构如下f). ⼀般的项⽬⽬录中,在java Resources⽬录下,还有src/main/java,src/main/test/java,src/main/test/resources这三个source folder,需要⼿动创建。
在下⾯的步骤中会讲到如何补齐这三个⽬录。
3、修改项⽬基本设置a). 右键此项⽬名称->Properties->Java Build path,点击source标签。
b). 提⽰ hello/src/main/java (missing)和hello/src/test/java (missing)。
⼀般的项⽬⽬录中,在java Resources⽬录下,还会有src/main/test/resources这个source folder。
将missing的先删除,再重新创建,缺少的直接创建。
点右键操作按键进⾏删除和添加。
c). 修改完整,效果如下图d). 接下来再修改libraries的配置,jre使⽤1.7版本。
选中JRE System Library->edit ,更换版本。
e). 再修改⼀下order and export⾥的配置,主要是调整这四个⽬录的显⽰顺序,调为⾃⼰喜欢的顺序即可f). 接下来再修改project facets,先将java修改为1.7。
SpringMVC的配置文件
SpringMVC的配置⽂件⼀、root标签跟spring配置⼀样,root标签是beans,毕竟springmvc是spring的⼀个模块在springmvc⾥,⾃动扫描主要是配置controller:⼆、⾃动扫描:⼆、⾃动扫描:在<context:component-scan base-package="com.xxx.controller"/>三、解析器Resolver:解析器有很多种,⽐较重要的是ViewResolverViewResolver也有很多种,其中⽐较重要和常⽤的是InternalResourceViewResolver(内部资源视图解析器)代码:<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/WEB-INF/jsp/" /><property name="suffix" value=".jsp" /></bean>如果没有视图解析器,我们在controller⾥⾯的代码是这样的:@Controllerpublic class LoginActionController {@RequestMapping("/index")public String toIndex(HttpServletRequest request, ModelMap map, HttpSession session) {return "/WEB-INF/jsp/index.jsp";}⽽使⽤了视图解析器,我们的代码是这样的:@Controllerpublic class LoginActionController {@RequestMapping("/index")public String toIndex(HttpServletRequest request, ModelMap map, HttpSession session) {return "index";}区别在最后⼀句,我们不需要给出⽬标视图的全路径了。
mvc流程
mvc流程MVC(Model-View-Controller)是一种用于构建应用程序的软件架构模式,通过将应用程序的逻辑分成三个部分(模型、视图和控制器)来组织代码,以达到分离关注点和提高代码的可维护性和可复用性的目的。
MVC模式的流程如下:1. 用户操作:用户与视图(View)进行交互,触发事件或用户输入,例如点击按钮、表单提交等。
2. 控制器响应:控制器(Controller)接收到用户的操作,并根据操作的类型和数据做出相应的处理。
控制器是连接模型和视图的中间人,它负责接收用户的请求,处理请求,并将结果返回给视图。
3. 模型更新:控制器根据用户的操作,调用对应的模型(Model)来进行数据的处理和更新。
模型是应用程序的核心部分,负责存储和管理数据,并提供对数据的操作和访问的方法。
4. 数据传递:模型更新完数据后,将数据传递给视图。
视图是用于展示数据的部分,它根据模型的数据来更新界面。
5. 视图更新:视图根据接收到的数据更新界面,将新的数据呈现给用户。
视图只负责展示数据,不处理数据的逻辑。
6. 用户反馈:用户看到界面的更新后,根据需要再次进行操作,从而形成一个循环。
用户可以通过视图对数据进行修改和操作,然后再次提交给控制器进行处理。
通过MVC的流程,实现了视图与模型的解耦,使得应用程序的代码更加清晰和易于维护。
控制器作为中间人,处理用户的请求和更新模型,起到了连接各个部分的作用。
模型负责数据的处理和存储,视图负责数据的展示,各个部分的职责清晰划分,易于理解和扩展。
总结起来,MVC模式的流程可以概括为用户操作、控制器响应、模型更新、数据传递、视图更新、用户反馈的循环过程。
通过这个过程,实现了应用程序的解耦,提高了代码的可维护性和可复用性。
同时,MVC模式也可以提高开发效率,不同开发人员可以同时负责不同的部分,从而提升团队的合作效率。
使用Maven搭建SpringMVC项目的步骤(图文教程)
使⽤Maven搭建SpringMVC项⽬的步骤(图⽂教程)约定电脑都安装了eclipse,且已配置好Maven以及eclipse插件。
1.Eclipse 2.maven1、新建⼀个Maven Project2、选择⼯作空间3、搭建Web⼯程,我们选择maven-archetype-webapp类型4、填写项⽬参数,如图5、以上步骤完成时的⼯程结构⽬录6、可以查看或修改发布⽬录7、确保勾选上Dynamic Web Module和Java8、完成以上步骤,我们的⼯程就是⼀个Web项⽬了,接着我们赋予⼯程的springmvc特性,配置web.xml,使其具有springmvc 特性,主要配置两处,⼀个是ContextLoaderListener,⼀个是DispatcherServlet。
代码如下:<?xml version="1.0" encoding="UTF-8"?><web-app version="2.5" xmlns="/xml/ns/javaee"xmlns:xsi="/2001/XMLSchema-instance"xsi:schemaLocation="/xml/ns/javaee/xml/ns/javaee/web-app_2_5.xsd"><!-- 配置web.xml,使其具有springmvc特性,主要配置两处,⼀个是ContextLoaderListener,⼀个是DispatcherServlet --><context-param><param-name>contextConfigLocation</param-name><param-value>classpath*:applicationContext.xml</param-value></context-param><!-- 配置ContextLoaderListener表⽰,该⼯程要以spring的⽅式启动。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
Springmvc框架配置步骤小弟是个新手,有不对的地方请tell me,一起研究探讨。
谢谢。
1062140832@配置springmvc框架其实不是很难,要现有一个总体的认识,确定要分几步,每一步主要是干什么,不要太盲目。
以为web.xml是项目的入口,所以所有的配置文件,都必须引入到wem.xml中,不然,配置了等于没用。
所以,要先从入口入手。
配置web.xml1、首先引入springmvc-servlet.xml文件<!-- 配置框架springmvc,配置文件所在位置--><servlet><servlet-name>springMVC</servlet-name><servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class><init-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring/mvc/springmvc-servlet.xml</param-value> </init-param><load-on-startup>1</load-on-startup></servlet>2、将spring加载到web.xml中<!-- 将spring 加载到web中--><listener><listener-class>org.springframework.web.context.ContextLoaderListener</listener -class> </listener>3、配置上下文路径<!-- 配置上下文路径--><context-param><param-name>contextConfigLocation</param-name><param-value>/WEB-INF/spring/spring.xml,/WEB-INF/spring/spring-*.xml</param-value> </context-param>说明:如果有很多的关于spring的配置文件,建议分开写,比如事务一个文件(spring-transaction.xml),springmvc-hibernate.xml一个配置文件,这样方便读写。
4、配置项目路径<!-- 设置url路径/ 表示项目名称--><servlet-mapping><servlet-name>springMVC</servlet-name><url-pattern>/</url-pattern></servlet-mapping>5、配置过滤器<!-- 配置过滤器--><filter><filter-name>openSession</filter-name><filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class></filter><filter-mapping><filter-name>openSession</filter-name><url-pattern>/*</url-pattern></filter-mapping>说明:什么样的文件进入框架6、设置编码格式<!-- 设置编码格式为utf-8 --><filter><filter-name>encodingFilter</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>encodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>配置springmvc-servlet.xml<!-- 注解扫描包--><context:component-scan base-package="com.phome.controller.**"/> 说明:base-package为项目要扫描的包路径名称,要写全路径<!-- 配置启用注解的方式--><mvc:annotation-driven/>说明:加上这句话才能使用注解的方式<!--配置要过滤的文件类型--><bean id="viewResolver"class="org.springframework.web.servlet.view.InternalResourceViewResolver"><property name="prefix" value="/"></property><property name="suffix" value=".jsp"></property></bean><!-- 根据需要配置,静态文件的路径位置--><mvc:resources location="/css/" mapping="/css/**"/><mvc:resources location="/js/" mapping="/js/**"/><mvc:resources location="/img/" mapping="/img/**"/>配置springmvc-hibernate.xml<beans> <!-- 数据库的连接信息--><bean id="dataSource"class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/><property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl" /><property name="username" value="system" /><property name="password" value="root" /></bean><!-- 配置sessionfactory --><bean id="sessionFactory"class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"><property name="dataSource" ref="dataSource"/><property name="hibernateProperties"><props><propkey="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop><prop key="hibernate.hbm2ddl.auto">update</prop><prop key="hibernate.show_sql">true</prop> <!-- hibernate 的拼写的sql在控制台输出--><prop key="hiberante.format_sql">true</prop> <!-- 使用hibernate 的标准sql --></props></property><property name="configLocations"><list><value>classpath*:com/phome/cofig/hibernate.cfg.xml</value> <!-- 对象关系映射,即实体类与数据库表的对应信息,这里采用注释的方式,而不采用xml 文件的形式--></list></property></bean><!-- 配置事务--><bean id="transactionManager"class="org.springframework.orm.hibernate4.HibernateTransactionManager"><property name="sessionFactory" ref="sessionFactory" /></bean><bean id="transactionBese"class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"lazy-init="true" abstract="true"><property name="transactionManager" ref="transactionManager"></property><property name="transactionAttributes"><props> <!-- 定义什么样的方法会用到事务,所有带add*,update*,insert*,find*,delete*,get*,set*方法开头的都可以用事务管理--><prop key="add*">PROPAGATION_REQUIRED,-Exception</prop><prop key="update*">PROPAGATION_REQUIRED,-Exception</prop><prop key="insert*">PROPAGATION_REQUIRED,-Exception</prop><prop key="find*">PROPAGATION_REQUIRED,-Exception</prop><prop key="delete*">PROPAGATION_REQUIRED,-Exception</prop><prop key="get*">PROPAGATION_NEVER</prop><prop key="set*">PROPAGATION_NEVER</prop></props></property></bean></beans>配置spring.xml<!-- 配置bean的注入方式,以注解(以@开始)的方式注入bean --><!-- 以注解方式注入bean --><context:component-scan base-package="com.phome" /><!-- 以注解方式注入bean的属性--><context:annotation-config />备注:hibernate.cfg.xml:代码<hibernate-configuration><session-factory name="er" /></hibernate-configuration>实体User:package com.phome.entity;import javax.persistence.Column;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.Id;import javax.persistence.Table;import org.hibernate.annotations.GenericGenerator;@Entity@Table(name="TT_USER") //tt_user是数据库表名主键策略是uuidpublic class User {@Id@GeneratedValue(generator = "system-uuid")@GenericGenerator(name = "system-uuid", strategy = "uuid")@Column(length=32)private String id;@Column(length=15)private String username;@Column(length=15)private String userpass;@Column(length=15)private String date;public String getId() {return id;}public void setId(String id) {this.id = id;}public String getUsername() {return username;}public void setUsername(String username) { ername = username;}public String getUserpass() {return userpass;}public void setUserpass(String userpass) {erpass = userpass;}public String getDate() {return date;}public void setDate(String date) {this.date = date;}}。