SpringMvc自学心得

最新推荐文章于 2022-06-20 18:24:50 发布

xietianaa

最新推荐文章于 2022-06-20 18:24:50 发布

阅读量771

点赞数

分类专栏： SpringMvc 文章标签： springmvc 软件开发 interface 框架

本文链接：https://blog.csdn.net/xietianaa/article/details/39270319

版权

SpringMvc 专栏收录该内容

0 篇文章 0 订阅

订阅专栏

在此之前，也了解些，ssh框架的开发，但是由于实习的时候公司并没有用到，是一家做银行软件的公司，其实我在这里不得不吐槽一下了，有些大的金融软件公司的软件开发都是在一些快速开发平台上做的，就算是不怎么熟悉的人，就甚至不是学计算机的人，经过一段短时间的培训都可以上手了。所以我在这奉劝一些刚毕业，或者找实习岗位的同学们还是考虑清楚入不入职吧。以我的亲身经历来讲，做了将近一年了，其实一些实用主流的技术根本接触不到，但是却也挺累的，只学到了些业务方面的知识。在目前这个软件行业，技术还是占主流的，业务知识，只能适合特定的某些软件行业。当然，做软件的技术业务都是需要懂的，但是我还是认为技术更为重要。最起码，等你辞职的时候，换一份工作会容易的许多。

由于没有做过ssh整合的项目，所以学习springMvc来会困难一些。很多人说springmvc会比三大框架要来的实用，方便些，以后可能会是主流的框架。所以我就硬着头皮自学起来，可能还是不是怎么很清楚，但我想，万事开头难嘛，先踏入一步再说！

首先，第一步前篇一律的找包。我这里是springmvc与hirbernate整合的demo。所以包需要：

刚导入的时候，它还报java.util包未找到，我查了下是在这里面没有，所以我就去网上下，可惜，下不到，不知道为什么。然后我就点了下错误，双击下就好了.... 可能是自己导入了吧。

第二步，写配置文件，分别是web.xml、xxx-servlet.xml、applicationContext.xml如果是单纯的简单springmvc搭建的话可不需要applicationContext.xml.那些配置都可以写到xxx-servlet.xml中。像如果整合一些别的框架，或者是springmvc的事务之类的配置就必须写到applicationContext.xml中了。这里整合了hirbernate，所以hirbernate的数据源配置之类的必须配置在这里面。具体的一些配置其实可以去下一个demo稍微修改就好了。

web.xml :

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  <display-name>s3h3</display-name>
   <context-param>  
     <param-name>contextConfigLocation</param-name>  
     <param-value>classpath:applicationContext*.xml</param-value>  //这里是指定applicationContext配置文件的路径，应为可能会有多个这种配置文件所以用*代替，
 </context-param>                                                   //这里表示的是src根目录下
  <listener>  
     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  //这里是配置监听，必须要的。
 </listener>  

 <servlet>  
     <servlet-name>spring</servlet-name>  
     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  //其实也是一个servlet继承了httpservlet。主要用于控制流程。
     <load-on-startup>1</load-on-startup>     //大于0表示在容器启动时，初始化这个servlet。在初始化这个servlet时候容器会自己去找mapping里面的spring-servlet.xml
 </servlet>                                   //文件。
 <servlet-mapping>                             //和上面的servlet想匹配的
     <servlet-name>spring</servlet-name>        //   这个name就是xxx-servlet.xml 里面的xxx，spring-servlet.xml。下面配置的*.do表示所有以.do结尾的请求都会交由spring<pre name="code" class="html">                                                //的DispatcherServlet来处理。
     <url-pattern>*.do</url-pattern>            //定义一个映射
 </servlet-mapping>  
  <welcome-file-list>
    <welcome-file>index.jsp</welcome-file>
  </welcome-file-list>
</web-app>

接下来是xxx-servlet.xml

（spring的核心就是把大多数几乎所有的对象都转换成bean来管理）

<?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"  
  	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-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
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 	
 	<context:annotation-config />                                   //启用springMVC的注解功能
        
      <context:component-scan base-package="com.mvc.controller" />     //这里表示启动对包的自动扫描   
     <!-- 完成请求和注解POJO的映射 --> 
      <bean class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />  
     
       <!-- 对模型视图名称的解析，即在模型视图名称添加前后缀 -->  
       <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
          p:prefix="/WEB-INF/view/" p:suffix=".jsp" />  //prefix里的值表示你所创建的视图页面要放在哪个文件下面。suffix表示.jsp页面。其实这些都是可以自己配置的
                                                        //可以允许有多种。  
       <bean id="multipartResolver"  
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver"     //用于上传文件的配置，也可以在java中直接用<span>CommonsMultipartResolver </span>
          p:defaultEncoding="utf-8" />  //类来上传文件。springMvc中有多种上传文件方式，有需要可以百度看一下。
 </beans>

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:p="http://www.springframework.org/schema/p" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	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:annotation-config />
	<context:component-scan base-package="com.mvc" />  <!-- 自动扫描所有注解该路径 -->

	<context:property-placeholder location="classpath:/hibernate.properties" />      //hibernate数据源配置等文件

	<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />                             //把dataSource传入进去
		<property name="hibernateProperties">                                     
			<props>
				<prop key="hibernate.dialect">${dataSource.dialect}</prop>       //hibernate.properties里dataSource.dialect（方言）的值，所使用的数据库
				<prop key="hibernate.hbm2ddl.auto">${dataSource.hbm2ddl.auto}</prop>
				<prop key="hibernate.hbm2ddl.auto">update</prop>
			</props>
		</property>
		<property name="packagesToScan">
			<list>
				<value>com.mvc.entity</value><!-- 扫描实体类，也就是平时所说的model 可以添加多个value-->
			</list>
	   </property>
	</bean>

	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <span style="color:#000000;">  </span><span style="color:#0800;"><!--</span><span style="color:#0800;"> 定义事务管理器（声明式的事务） </span><span style="color:#0800;">--></span>
		<property name="sessionFactory" ref="sessionFactory" />
		<property name="dataSource" ref="dataSource" />
	</bean>

	<bean id="dataSource"                                          <span style="color:#000000;">  </span><span style="color:#0800;"><!--</span><span style="color:#0800;"> <span style="color:#0800;">定义数据源配置</span> </span><span style="color:#0800;">--></span>
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${dataSource.driverClassName}" />
		<property name="url" value="${dataSource.url}" />
		<property name="username" value="${dataSource.username}" />
		<property name="password" value="${dataSource.password}" />
	</bean>
	<!-- Dao的实现 定义dao的bean-->
	<bean id="entityDao" class="com.mvc.dao.EntityDaoImpl">  
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>
	<tx:annotation-driven transaction-manager="transactionManager" />
	<tx:annotation-driven mode="aspectj"/>
  
    <aop:aspectj-autoproxy/>  // 定义切面编程配置
</beans>

好了，基本的配置文件以及差不多配置好了。下面是jsp页面的编写。

student.jsp 用来显示与操作数据。

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ include file="/include/head.jsp"%>
<!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>添加</title>
<script language="javascript" src="<%=request.getContextPath()%>/script/jquery.min.js"></script>
<style>
table{  border-collapse:collapse;  }
td{  border:1px solid #f00;  }
</style>
<script type="text/javascript">
function add(){            
 window.location.href="<%=request.getContextPath() %>/student.do?method=add";           //根据@RequestMapping（url，param）寻找到相应的处理函数
}

function del(id){
$.ajax( {                               //jquery.ajax   
	type : "POST",
	url : "<%=request.getContextPath()%>/student.do?method=del&id=" + id,
	dataType: "json",
	success : function(data) {            //回调函数， 交互的数据为json 这里的输入数据参数是id=id和method=del，也可是data：{"",""}。找到相应的处理函数通过url。返回数据位json字符串。
		if(data.del == "true"){
			alert("删除成功！");
			$("#" + id).remove();    //页面上的删除
		}
		else{
			alert("删除失败！");
		}
	},
	error :function(){                     //错误处理
		alert("网络连接出错！");
	}
});
}
</script>
</head>
<body>

<input id="add" type="button" οnclick="add()" value="添加"/>
<table >
	<tr>
		<td>序号</td>
		<td>姓名</td>
		<td>密码</td>
		<td>操作</td>
	</tr>
	<c:forEach items="${list}" var="student">                    //jstl标签，循环输出list ，在java处理函数中把数据存入ModelMap（springmvc里自带的，就是为了存与页面交互的数据） 的modelMap中key，value形式
	<tr id="<c:out value="${student.id}"/>">
		<td><c:out value="${student.id}"/></td>
		<td><c:out value="${student.user}"/></td>
		<td><c:out value="${student.psw}"/></td>
		<td>
			<input type="button" value="编辑"/>     
			<input type="button" οnclick="del('<c:out value="${student.id}"/>')" value="删除"/>
		</td>
	</tr>
	</c:forEach>
</table>
</body>
</html>

student_add.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<%@ include file="/include/head.jsp"%>
<!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>学生添加</title>
<script type="text/javascript">
function turnback(){
	window.location.href="<%=request.getContextPath() %>/student.do";
}
</script>
</head>
<body>
<form method="post" action="<%=request.getContextPath() %>/student.do?method=save">
<div><c:out value="${addstate}"></c:out></div>                                            //这里是form表单提交后根据action找到相应处理函数，在return会这个页面的时候存放在modelMap里的值。
<table>
	<tr><td>姓名</td><td><input id="user" name="user" type="text" /></td></tr>
	<tr><td>密码</td><td><input id="psw" name="psw"  type="text" /></td></tr>
	<tr><td colSpan="2" align="center"><input type="submit" value="提交"/><input type="button" οnclick="turnback()" value="返回" /> </td></tr>
</table>

</form>
</body>
</html>

接下来就是java文件的编写了。

首先当然是建立实体bean，student.java。由于用的是hibernate的注解所以如下：

package com.mvc.entity;

import java.io.Serializable;

import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity                      //实体注解，让hibernate知道这是个实体bean
@Table(name = "student")     //所属表注解
public class Student implements Serializable {
	private static final long serialVersionUID = 1L;
	@Id
	@Basic(optional = false)                //对于字段      //在这里还未使用到hibernate的表之间的对应关系的功能。
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	@Column(name = "id", nullable = false)
	private Integer id;
	@Column(name = "name")
	private String user;
	@Column(name = "psw")
	private String psw;
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	
	public String getUser() {
		return user;
	}
	public void setUser(String user) {
		this.user = user;
	}
	public String getPsw() {
		return psw;
	}
	public void setPsw(String psw) {
		this.psw = psw;
	}
}

实体建设完成，接下来就是如何使用这实体，实体多用于与数据库打交道类中，也就是dao层。dao层主要作用是与数据的的交互。

先建立dao的接口。（为什么要使用接口呢？是这样的，我们在new对象的时候，传统的是：XxxClass bbb=new XxxClass(); 这样做会使得代码的耦合度非常高。使用接口之后是这样：【接口名】 bbb= new 【接口的实现】因为实现可以是有多种，而且一个类可以实现多个接口。这样耦合度就降低了些）

package com.mvc.dao;

import java.util.List;

public interface EntityDao {
	public List<Object> createQuery(final String queryString);
	public Object save(final Object model);
	public void update(final Object model);
	public void delete(final Object model);
}

接口的实现类

请看class继承了一个类，HibernateDaoSupport 这是hirbenate3提供的一个包装类，继承了这个类之后就可以不需要管hirbernate的事务了，不不要创建sessionfactory ，getsession ，不需要关闭sessionfactory。它本身就已经getssion了。直接使用就好了。

package com.mvc.dao;

import java.util.List;

import org.hibernate.Query;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

public class EntityDaoImpl extends HibernateDaoSupport implements EntityDao{
	public List<Object> createQuery(final String queryString) {
		return (List<Object>) getHibernateTemplate().execute(
				new HibernateCallback<Object>() {       <span style="color:#FF6666;">//回调函数</span>
					public Object doInHibernate(org.hibernate.Session session)   <span style="color:#FF0000;"> // 看名字就知道了，doInHibernate 事务的事情已经在里面做好了。</span>
							throws org.hibernate.HibernateException {
						Query query = session.createQuery(queryString);  //这里的queryString 可以是sql 也可以是hql   
                                             <span style="color:#FF0000;">// 如果这里用的是session.find(String queryString)  //这里就必须是hql 不然查询出来的会有错误</span>
						List<Object> rows = query.list();
						return rows;
					}
				});
	}
	public Object save(final Object model) {
		return  getHibernateTemplate().execute(
				new HibernateCallback<Object>() {
					public Object doInHibernate(org.hibernate.Session session)
							throws org.hibernate.HibernateException {
						session.save(model);
						return null;
					}
				});
	}
	public void update(final Object model) {
		getHibernateTemplate().execute(new HibernateCallback<Object>() {
			public Object doInHibernate(org.hibernate.Session session)
					throws org.hibernate.HibernateException {
				session.update(model);
				return null;
			}
		});
	}
	public void delete(final Object model) {
		getHibernateTemplate().execute(new HibernateCallback<Object>() {
			public Object doInHibernate(org.hibernate.Session session)
					throws org.hibernate.HibernateException {
				session.delete(model);
				return null;
			}
		});
	}
}

dao层创建完成，接下来当然就是业务层了是吧。在这里我们可以做些业务逻辑的处理。

package com.mvc.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.mvc.dao.EntityDao;
import com.mvc.entity.Student;

@Service
public class StudentService {
	@Autowired                        //  spring的注解方法， 如果不使用这个， entityDao就要加上get set 方法 
	private EntityDao entityDao;   //使用接口来调用方法
	
	@Transactional
	public List<Object> getStudentList(){
		StringBuffer sff = new StringBuffer();
		sff.append("select a from ").append(Student.class.getSimpleName()).append(" a ");
		List<Object> list = entityDao.createQuery(sff.toString());
		return list;
	}
	
	public void save(Student st){
		entityDao.save(st);
	}
	public void delete(Object obj){
		entityDao.delete(obj);
	}
}

最后的就是springMvc中主要的，用来使前台传入的数据与后台交互的类了。前台通过student.do?method=save之类的类似url方式，通过get post 对服务器进行请求。 student.do 表示所对应的处理类（@RequestMapping("/student.do")）， method=save 还有几种方式用来指定是哪个方法处理(@RequestMapping(params="method=seve"))。 @Controller 在springmvc中相当于mvc的控制层。

package com.mvc.controller;

import java.util.List;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.servlet.ModelAndView;

import com.mvc.entity.Student;
import com.mvc.service.StudentService;

@Controller
@RequestMapping("/student.do")
public class StudentController {
	protected final transient Log log = LogFactory
	.getLog(StudentController.class);
	@Autowired
	private StudentService studentService;
	public StudentController(){
		
	}
	
	@RequestMapping
	public String load(ModelMap modelMap){
		List<Object> list = studentService.getStudentList();
		modelMap.put("list", list);
		return "student";
	}
	
	@RequestMapping(params = "method=add")
	public String add(HttpServletRequest request, ModelMap modelMap) throws Exception{
		return "student_add";
	}
	
	@RequestMapping(params = "method=save")
	public String save(HttpServletRequest request, ModelMap modelMap){
		String user = request.getParameter("user");
		String psw = request.getParameter("psw");
		Student st = new Student();
		st.setUser(user);
		st.setPsw(psw);
		try{
			studentService.save(st);
			modelMap.put("addstate", "添加成功");
		}
		catch(Exception e){
			log.error(e.getMessage());
			modelMap.put("addstate", "添加失败");
		}
		
		return "student_add";
	}
	
	@RequestMapping(params = "method=del")                                            //<%=request.getContextPath()%>/student.do?method=del&id=" + id
	public void del(@RequestParam("id") String id, HttpServletResponse response){     //  页面上传入了id 
		try{
			Student st = new Student();
			st.setId(Integer.valueOf(id));
			studentService.delete(st);
			response.getWriter().print("{\"del\":\"true\"}");                 //ajax中所需要的json数据。   response.getWriter().print("aaa")   用ajax 返回的data 就是print中的值。
		}
		catch(Exception e){
			log.error(e.getMessage());
			e.printStackTrace();
		}
	}
}

题外知识点：

response.getWriter().write()与out.print()的区别

1、首先介绍write()和print()方法的区别：
  (1)、write()：仅支持输出字符类型数据，字符、字符数组、字符串等
  (2)、print()：可以将各种类型（包括Object）的数据通过默认编码转换成bytes字节形式，这些字节都通过write(int c)方法被输出
2、介绍response.getWriter()和out的区别：
  (1)、out和response.getWriter的类不一样，一个是JspWriter，另一个是java.io.PrintWriter。
  (2)、执行原理不同:JspWriter相当于一个带缓存功能的printWriter，它不是直接将数据输出到页面，而是将数据刷新到response的缓冲区后再输出，
      response.getWriter直接输出数据（response.print()），所以（out.print）只能在其后输出。
  (3)、out为jsp的内置对象，刷新jsp页面，自动初始化获得out对象，所以使用out对象是需要刷新页面的，
       而response.getWriter()响应信息通过out对象输出到网页上，当响应结束时它自动被关闭，与jsp页面无关，无需刷新页面
       形象的比喻：当我们调用response.getWriter()这个对象同时获得了网页的画笔，这时你就可以通过这个画笔在网页上画任何你想要显示的东西。
  (4)、out的print()方法和println()方法在缓冲区溢出并且没有自动刷新时候会产生ioexception，
       而response.getWrite()方法的print和println中都是抑制ioexception异常的，不会有ioexception

   out.println(""); 方法并不能也页面布局换行，只能领html代码换行，要实现页面布局换行可以：out.println("</br>");