慕课 springmvc 起步 maven wbe

来源：互联网发布：mac 加速器编辑：程序博客网时间：2024/05/01 20:28

如何从官网下载jdk1.7

http://jingyan.baidu.com/article/f7ff0bfc7f85532e27bb137c.html

使用IntelliJ IDEA 14和Maven创建java web项目
http://www.cnblogs.com/jifeng/p/4658765.html

(使用IntelliJ IDEA 15和Maven创建Java Web项目
http://blog.csdn.net/myarrow/article/details/50824793

IntelliJ IDEA TOMCAT部署
http://chemnk.blog.163.com/blog/static/20146312020134195048695/
)

IntelliJ IDEA 使用心得与常用快捷键
http://www.blogjava.net/rockblue1988/archive/2014/10/24/418994.html

1.spring mvc基本概念

DispatcherServlet 前端控制器
处理前端请求，进行分发

ModelAndView---Model的具体表现
有人用Model,有人用Map,DispatcherServlet统统转化成ModelAndView,因此我们认为这个是Model的具体表现

HandlerExecutionChain---handler执行链条
这个就是应用了java的反射机制

HandlerMapping作用
1.告诉我们的DispatcherServlet，那个控制器获得请求。<br>
2.HandlerMapping工作完毕之后，可以给DispatcherServlet一个HandlerAdapter,<br>
HandlerAdapter包括具体的controller实例和HandlerInterceptor外围包裹（如图所示），构成执行链条往下总

HandlerInterceptor拦截器--是一个接口
如果配置了这个类，并实现这个方法，可以做很多事情

HandlerAdapter -- controller的表现形式
适配器模式，适配DispatcherServlet可以很轻松地去调用我们的适配器

Maven

1.pom即project object model，它主要是一个xml文件，用来包含项目中与其他jar包之间的依赖关系
2.依赖关系：就是说一个项目可能会依赖于其他项目的jar包，只要使用了maven，在pom中写出与此项目直接依赖的包，那么那些间接依赖的就会自动导入。
3.maven是通过坐标来标识依赖的jar包的，这个坐标包括groupId，artifactId，version和package，其中package是可以从缺省的

Maven的安装

1.下载并解压Maven：https://archive.apache.org/dist/maven/maven-3/3.2.5/binaries/
注意版本问题，3.3以上版本需要jdk7环境（ Maven 3.3 requires JDK 1.7 or above, Maven 3.2 requires JDK 1.6 or above, while Maven 3.0/3.1 requires JDK 1.5 or above）
2.配置环境变量
（1）M2_HOME:解压位置
（2）Path:%M2_HOME%\bin
测试maven安装：mvn -version，显示版本号，则成功。
3.配置Maven配置文件（本地仓库路径，镜像）
（1）创建%M2_HOME%\.m2文件夹（该文件夹命名为.m2. ）
(2)将%M2_HOME%\conf\settings.xml放入.xml文件夹下
（3）不配置localRepository，会使用默认的即上面绿色的Default:后面的路径,即修改本地仓库位置。
（4）为 maven 设置 mirror,修改中央仓库的替代仓库地网址
<mirror>
<id>UK</id>
<mirrorOf>central</mirrorOf>
<name>UK Central</name>
<url>http://uk.maven.org/maven2</url>
</mirror>
(5)myeclipse配置Maven
http://my.oschina.net/u/2307376/blog/528126 (修改maven本地仓库位置)
http://blog.sina.com.cn/s/blog_4f925fc30102epdv.html (MyEclipse创建Maven工程)

创建Maven项目：

（1）mvn命令，在需要创建目录的工作区执行此命令（mvn archetype:generate -DgroupId=brandi-arthur -DartifactId=spring-mvc-demo -DarchetypeArtifactId=maven-archetype-webapp）
（2）mvn eclipse:myeclipse -Dwtpversion=2.0 :maven工程转化为mycelipse工程
（3）File----> Import --->Exsiting Projects into Workspace--->Browse选择刚刚建立的maven项目

SpringMvc的小例子的实现过程：

1：导入maven自动构建的目录结构
2：添加缺失的java目录
3：观察和配置pom.xml文件，这个文件非常的重要，是maven管理各种依赖关系的地方
Spring的版本管理
依赖关系的管理
依赖管理——我们的项目需要什么软件包，有Maven来查找和管理
加入一些插件比如：jetty
4：配置web.xml文件
配置servlet
这相当重要，最好反复的看看和理解
5：配置Spring的配置文件
注解的配置
配置注解驱动器
配置组件扫描器
配置试图解析器
5：创建对应的资源文件夹，比如：jsp/js/css/img等
6：创建对应的Controller
7：创建对应的试图
8：启动应用的容器或者服务器 ——这里是 mvn jetty:run 需要在项目的目录下运行才可以的
9：打开浏览器，输入访问应用的URL测试是否访问到我们的项目

配置文件的编写是非常重要的，也是比较难懂的地方，难懂在于有许多的东西都是隐含不见的，当然也是搭建一个项目的关键和基础。

项目实现：

1）pom.xml

2)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:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">

<context:annotation-config />

<context:component-scan base-package="com.imooc.mvcdemo">
<context:exclude-filter type="annotation"
expression="org.springframework.stereotype.Controller" />
</context:component-scan>
</beans>

3)web.xml
<web-app
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_3_0.xsd"
version="3.0">

<display-name>Archetype Created Web Application</display-name>


<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/configs/spring/applicationContext*.xml</param-value>
</context-param>


<context:component-scan base-package="com.imooc.mvcdemo">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller" />
</context:component-scan>


<servlet>
<servlet-name>mvc-dispatcher</servlet-name>
<servlet-class> org.springframework.web.servlet.DispatcherServlet</servlet-class>

<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/configs/spring/mvc-dispatcher-servlet.xml</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>mvc-dispatcher</servlet-name>

<url-pattern>/</url-pattern>
</servlet-mapping>
</web-app>

4)mvc-dispatcher-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:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc.xsd">




<context:annotation-config />


<context:component-scan base-package="com.imooc.mvcdemo">
<context:include-filter type="annotation"
expression="org.springframework.stereotype.Controller" />
</context:component-scan>




<mvc:annotation-driven />

<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass"
value="org.springframework.web.servlet.view.JstlView" />
<property name="prefix" value="/WEB-INF/jsps/" />
<property name="suffix" value=".jsp" />
</bean>
</beans>

5)HelloMvcController.java
package com.imooc.mvcdemo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

//告诉DispatcherServlet相关的容器，这是一个Controller，管理好这个bean哦
@Controller
//类级别的RequestMapping，告诉DispatcherServlet由这个类负责处理以跟URL。
//HandlerMapping依靠这个标签来工作
@RequestMapping("/hello")
public class HelloMvcController {

//方法级别的RequestMapping，限制并缩小了URL路径匹配，同类级别的标签协同工作，最终确定拦截到的URL由那个方法处理
@RequestMapping("/mvc")
public String helloMvc() {

//视图渲染，/WEB-INF/jsps/home.jsp
return "home";
}

}

6)/WEB-INF/jsps/home.jsp

7)http://localhost:8080/hello/mvc 转到home.jsp

项目2：
Json是一种轻量级的数据书写格式.
json的优点也使得Restful的webservice使用越来越广泛，逐渐由取代soap的趋势。
JSON是一种数据交换格式，Javascript语言处理这种数据格式比较容易，Javascript语言是现在Web开发中不可缺少的一种语言，所以，现在JSON这种数据交换格式被使用的越来越多了。
数据的本质没变，为了更好的处理，呈现的格式变换了，这个符合人类的利益。
ResponseEntity用来包装需要返回给页面的json数据格式
@ResponseBody @RequestBody是客户端与服务器通过交换数据，修改数据成为可能。还可以通过json推动数据到服务器。

1）mvc-dispatcher-servlet.xml

<bean
class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
<property name="order" value="1" />
<property name="mediaTypes">
<map>
<entry key="json" value="application/json" />
<entry key="xml" value="application/xml" />
<entry key="htm" value="text/html" />
</map>
</property>

<property name="defaultViews">
<list>

<bean
class="org.springframework.web.servlet.view.json.MappingJackson2JsonView">
</bean>
</list>
</property>
<property name="ignoreAcceptHeader" value="true" />
</bean>

8)CourseController.java
package com.imooc.mvcdemo.controller;

import java.io.File;
import java.io.IOException;
import java.util.Iterator;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.builder.ReflectionToStringBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PathVariable;
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.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;

import com.imooc.mvcdemo.model.Course;
import com.imooc.mvcdemo.service.CourseService;

@Controller
@RequestMapping("/courses")
// /courses/**
public class CourseController {

private static Logger log = LoggerFactory.getLogger(CourseController.class);

private CourseService courseService;

@Autowired
public void setCourseService(CourseService courseService) {
this.courseService = courseService;
}

//本方法将处理 /courses/view?courseId=123 形式的URL
@RequestMapping(value="/view", method=RequestMethod.GET)
public String viewCourse(@RequestParam("courseId") Integer courseId,
Model model) {

log.debug("In viewCourse, courseId = {}", courseId);
Course course = courseService.getCoursebyId(courseId);
model.addAttribute(course);
return "course_overview";
}

//本方法将处理 /courses/view2/123 形式的URL
@RequestMapping("/view2/{courseId}")
public String viewCourse2(@PathVariable("courseId") Integer courseId,
Map<String, Object> model) {

log.debug("In viewCourse2, courseId = {}", courseId);
Course course = courseService.getCoursebyId(courseId);
model.put("course",course);
return "course_overview";
}

//本方法将处理 /courses/view3?courseId=123 形式的URL
@RequestMapping("/view3")
public String viewCourse3(HttpServletRequest request) {

Integer courseId = Integer.valueOf(request.getParameter("courseId"));
Course course = courseService.getCoursebyId(courseId);
request.setAttribute("course",course);

return "course_overview";
}

@RequestMapping(value="/admin", method = RequestMethod.GET, params = "add")
public String createCourse(){
return "course_admin/edit";
}

@RequestMapping(value="/save", method = RequestMethod.POST)
public String doSave(@ModelAttribute Course course){

log.debug("Info of Course:");
log.debug(ReflectionToStringBuilder.toString(course));

//在此进行业务操作，比如数据库持久化
course.setCourseId(123);
return "redirect:view2/"+course.getCourseId();
}

@RequestMapping(value="/upload", method=RequestMethod.GET)
public String showUploadPage(@RequestParam(value= "multi", required = false) Boolean multi){
if(multi != null && multi){
return "course_admin/multifile";
}
return "course_admin/file";
}

@RequestMapping(value="/doUpload", method=RequestMethod.POST)
public String doUploadFile(@RequestParam("file") MultipartFile file) throws IOException{

if(!file.isEmpty()){
log.debug("Process file: {}", file.getOriginalFilename());
FileUtils.copyInputStreamToFile(file.getInputStream(), new File("c:\\temp\\imooc\\", System.currentTimeMillis()+ file.getOriginalFilename()));
}

return "success";
}

@RequestMapping(value="/doUpload2", method=RequestMethod.POST)
public String doUploadFile2(MultipartHttpServletRequest multiRequest) throws IOException{

Iterator<String> filesNames = multiRequest.getFileNames();
while(filesNames.hasNext()){
String fileName =filesNames.next();
MultipartFile file = multiRequest.getFile(fileName);
if(!file.isEmpty()){
log.debug("Process file: {}", file.getOriginalFilename());
FileUtils.copyInputStreamToFile(file.getInputStream(), new File("c:\\temp\\imooc\\", System.currentTimeMillis()+ file.getOriginalFilename()));
}

}

return "success";
}

@RequestMapping(value="/{courseId}",method=RequestMethod.GET)
public @ResponseBody Course getCourseInJson(@PathVariable Integer courseId){
return courseService.getCoursebyId(courseId);
}

@RequestMapping(value="/jsontype/{courseId}",method=RequestMethod.GET)
public ResponseEntity<Course> getCourseInJson2(@PathVariable Integer courseId){
Course course = courseService.getCoursebyId(courseId);
return new ResponseEntity<Course>(course, HttpStatus.OK);
}
}

2 0