java学习笔记汇总

作者: 王乐城愚人云端 | 来源:发表于2019-02-26 13:50 被阅读0次

1.spring boot实现热部署方式一 jrebel

只要点击resources右键最下位，选择Jrebel--rebel.xml 就会创建配置文件
然后每次更新只需要cmd+F9就会自动更新修改过的地方

2.spring boot实现热部署方式二 spring-boot-devtools

在spring boot下，使用这种方式更快！！！

添加此依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
        </dependency>

注意事项
在preference的build中的compiler中选择Build project automatically
第二步按shift alt cmd / 快捷键点击registry 选中compiler when app running

还有其他人说的几个其他要点，虽然我觉得并没什么用

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>//这点
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <fork>true</fork><!--和这点 如果没有该项配置，肯呢个devtools不会起作用，即应用不会restart -->
                </configuration>
            </plugin>
        </plugins>
    </build>

3.Bean的声明和作用

@Component 组件，没有明确的角色
@Service 在业务逻辑层 service层使用
@Repository 在数据访问层 dao层使用
@Controller 在展现层 MVC使用
注入Bean的注解
@Autowired Spring提供的注解 //主要使用这个
@Inject JSR-300提供的注解 //这个没有代码提示，没法用
@Resource JSR-250提供的注解 //这个和Autowired效果相同
注入Bean可以作用在方法和属性上，推荐注入在属性上，代码更少，层次更清晰

以Service注解为例
创建Bean FunctionService

@Service
public class FunctionService {
    public String sayService(String word){
        return "我是"+word;
    }
}

使用Bean UseFunctionService

@RestController
@Service//声明UseFunctionService是一个Bean,才能使用其他Bean
public class UseFunctionService {
    @Autowired//自动注入FunctionService Bean
    FunctionService functionService;

    @GetMapping(value = "service/{word}")
    public String sayHello(@PathVariable("word") String word){
        return functionService.sayService(word);
    }
}

4.我对aop切面的理解

如何创建一个aop切面

1.@Aspect注解声明一个切面
2.@Component让切面成为一个Bean
3.@PointCut注解声明切点
4.@After注解声明一个建言
5.可以通过java的反射获取注解上的属性
6.@Before注解声明一个建言，此建言直接使用拦截规则作为参数
我对aop的理解：aop就是建立一个抽象层，可以作用于多个对象，对多个对象实现相同的动作
比如Http的Request访问是一个对象，那么如果我们想对所有的Request进行前置动作，和后置
动作，那么就可以创建一个切面。aop即不用在Request中显示的写出来，又能发挥作用。
我将此类比于laravel的中间件

5.Bean的作用域

@Scope("Singleton") 一个Spring容器中只有一个Bean实例，此为Spring默认配置，全窗口共享一个实例
@Scope("Prototype") 每次调用新建一个Bean实例
@Scope("Request") 每次发起一个Http Request创建一个Bean实例
@Scope("Session") 每次创建一个Http Session创建一个Bean实例

6.spring EL 和资源调用

拥有以下作用
注入普通字符
注入操作系统属性
注入表达式运算结果
注入其他Bean的属性
注入文件内容
注入网址内容
注入属性文件

7.Bean的初始化和销毁

比如我们想在Bean初始化时做一些动作，销毁时做一些动作，就可以使用下面的jsr250
引入依赖

        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>jsr250-api</artifactId>
            <version>1.0</version>
        </dependency>

先创建BeanWayService
再创建JSR250WayService
最后创建PrePostConfig和Main

8.事件 Application Event

DemoEvent 继承ApplicationEvent接口,创建事件
DemoListener 继承ApplicationListener<DemoEvent>接口，并传入事件类型，接收处理
DemoPublisher 注入应用的环境，发布事件

9.组合注解

比如@Configuration和@ComponentScan("com.yurencloud")两个注解通常都是一起出现的，所以可以用spring提供的组合注解
@WiselyConfiguration("com.yurencloud")

10.最快的Hello World

直接在xxxApplication中写@RestController

@RestController
@SpringBootApplication//这个是核心注解，用来启动spring boot,这是一个组合注解，可以cmd+b来看原注解
public class SpringBoot2Application {

    @RequestMapping("/")
    String index(){
        return "Hello Spring Boot";
    }

    public static void main(String[] args) {
        SpringApplication.run(SpringBoot2Application.class, args);
    }
}

11.定制Banner,就是每次启动spring boot时，在控制台的欢迎图案

在src/main/resources下新建一个banner.txt,此文件中的字符就会作为欢迎图案
关闭欢迎图案

//在启动的main中添加
SpringApplication app = new SpringApplication(项目启动类.class);
app.setShowBanner(false);//关闭欢迎图案
app.run(args);//重新载入设置

12.全局配置文件

放到resources/config下
application.properties
application-dev.properties
application-prod.properties
application.yml
application-dev.yml
application-prod.yml

13.spring boot升级成HTTPS

letsencrypt 的使用方式还是一样，生成加密的文件
只需要在spring boot 的全局配置文件中添加上面的引用就可以，例如：

server.port: 8443
security.require-ssl=true
server.ssl.key-store:/etc/letsencrypt/live/example.com/keystore.p12
server.ssl.key-store-password: <your-password>
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcat`

14.网站的Favicon图标设置

只需要把favicon.ico这样取名的图标放到src/main/resources/static目录下就可以
关闭图标如下

spring.mvc.favicon.enabled=false

15.数据库查询，排序

在findAll中传入以面参数

new Sort(Sort.Direction.DESC,"id")

16.数据库查询，分页

先在定义数据仓库的地方给方法添加Pageable

Page<Admin> findAll(Pageable pageable);

然后使用的时候，就可以传递pageable实例对象参数
其中new PageRequest的第一个参数是offset

@GetMapping(value = "/admin/page/{id}")
    public Page<Admin> getListPage(@PathVariable Integer id){
        return adminRepository.findAll(new PageRequest(id,4));
    }

然后他返回的数据中，除了当前获取的数据外，还有用与分页的额外数据
以方便判断当前是最后一页，总共多少页，总共有多少条记录，每页多少条，是否排序，是否是第一条，当前多少条

"last":true,"totalPages":2,"totalElements":8,"size":4,"number":1,"sort":null,"first":false,"numberOfElements":4}

17.在resources下新建一个import.sql文件

每次重启spring boot之后都会自动的向数据库执行此文件
可以用来初始化测试数据
相当于laravel中的seeder

18.使用data-rest 来增强jpa，简化数据操作

原本我们要使用jpa来查询一条数据，那么要写repository,要创建model,要创建controller
现在我们只要在全局配置文件中引入REST的配置类，那么我们将自动创建所有的repository的REST风格的访问路径
在localhost:8080下可以看到我们可以通过哪些链接来访问这些数据

{
  "_links" : {
    "admins" : {
      "href" : "http://localhost:8080/admins{?page,size,sort}",
      "templated" : true
    },
    "girls" : {
      "href" : "http://localhost:8080/girls{?page,size,sort}",
      "templated" : true
    },
    "profile" : {
      "href" : "http://localhost:8080/profile"
    }
  }
}

如何使用REST呢

1.添加依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>

2.在你的配置文件中引入RepositoryRestMvcAutoConfiguration.class REST的配置文件

@Import(RepositoryRestMvcAutoConfiguration.class)

3.正常的创建每个数据表的repository和model，在model中要创建一个构造器包含所有参数并带super()

此时就可以通过http://localhost:8080/girls{?page,size,sort} 这样一个路径操作数据了
REST的通过访问方式的不同，来操作数据，可以用postman来进行测试
GET:获取数据
用GET方式，请求http://localhost:8080/girls/1 获取id为1的girl的信息

POST：添加数据
用POST方式，请求http://localhost:8080/girls 传递{"age":7,"cupSize":"D"}的json信息，会自动添加该数据，服务器会返回该数据

PUT：更新数据
用PUT方式，请求http://localhost:8080/girls/1 传递{"age":17,"cupSize":"D"}的json信息，会自动更新该数据，服务器会返回该数据

DELETE：删除数据
用DELETE方式，请求http://localhost:8080/girls/1 会删除id为1的gril数据

4.修改访问数据的路径
REST数据访问都是直接在根路径下的
http://localhost:8080/girls
我们可以在application.properties中添加
spring.data.rest.base-path= /api
那么路径就会变成
http://localhost:8080/api/girls
注意，默认的REST访问路径是数据表的小写复数形式比如 girl 就是 /girls

19.启动spring应用的几种方式

1.使用idea来启动应用，在导航栏或者右键都有启动按钮
2.使用mvn命令来启动mvn spring-boot:run
3.使用mvn命令编译mvn install,然后在tartget目录下会有xxx-SNAPSHOT.jar文件，使用java -jar xxx-SNAPSHOT.jar即可启动spring程序

20.使用properties或yml文件

二者的作用效果是一样的，只不过yml更加简练，所以推荐
application.properties

server.port=8081#在8081端口启动应用
server.context-path=/girl#给项目的根目录加上girl

application.yml

server:
  port: 8081#8081前记得有一个空格
  context-path: /girl
name: haha#如果是自定义的变量名，则要顶格写，每空两格则是一个嵌套
age: 18
name-age: "name is ${name} and age is ${age}"#可以在变量中引用变量
girl:
  girl-name: cindy
  girl-age: 20

21.使用注解来获取application.yml配置文件中的值

配置文件中的变量值名字是可以任意取的
注解都是作用于相邻的属性，方法

@Value("${varname}")
private String varname;

public String getVarname(){
    return varname
}

22.切换开发和生产不同环境的配置

application.yml

spring:
  profiles:
    active: dev#切换到application-dev.yml配置

application-dev.yml
application-prod.yml

23.同一个控制器设置多个不同的url访问地址

@RequestMapping(value={"/hello","/hi"},method=RequestMethod.GET)

给同一个控制器的类设置统一的前缀，在每个方法下设置单独的访问地址
@RequestMapping(value="/root")
public class GirlController{
@RequestMapping(value="hello",method=RequestMethod.GET)
public String sayHello(){//要用/root/hello才能访问此控制器
}
}

24.获取url中的参数

1.获取url片段参数
{id}设置参数占位符
@PathVariable("id") Integer id 使用注解把从url获取的参数值注入到id中

@RequestMapping(value={"/url/{id}",method=RequestMethod.GET)
public String getId(@PathVariable("id") Integer id){}

2.获取get序列化参数
@RequestParam("id") 当没有id的参数是，会报错
value为获取的参数的键，required是否一定要有这参数，defaultValue默认参数
@RequestParam(value="id",required=false,defaultValue="0")

25.简化@RequestMapping注解

@RequestMapping(value="/hello",method=RequestMethod.GET)
可以简化成下面的注解
@GetMapping(value="/hello")
还有post,put的@PostMaping,@PutMapping

26.操作数据库

在pom.xml中添加依赖
data-jpa是一种将数据库以对象的形式进行操作的一些定义，我认为就是ORM，其中hibernate就是jpa其中的一种实现

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

在application.yml中的spring参数下添加数据库的配置

  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/dbgirl
    username: root
    password: root
  jpa:
    hibernate:
      ddl-auto: create#create每次重启启动将会删除并重建数据库，update 更新，create-drop是在关闭应用时就删除数据库 
    show-sql: true

可以设置类来操作数据库，就像laravel migration一样

package com.yurencloud;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.GeneratedValue;

@Entity//创建实体
public class Girl {
    @Id//定义为primaryKey要引入包
    @GeneratedValue//自增
    private Integer id;

    private String cupSize;

    private Integer age;

    public Girl(){//设置无参构造器，注意

    }

    public Integer getId() {//所有的get和set方法
        return id;
    }

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

    public String getCupSize() {
        return cupSize;
    }

    public void setCupSize(String cupSize) {
        this.cupSize = cupSize;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

把数据查询到仓库,新建model

public interface GirlRepository extends JpaRepository<Girl,Integer>{
}

查询数据库

    @Autowired//注入model
    private GirlRepository girlRepository;

    @GetMapping(value = "girls")
    public List<Girl> getList(){//因为findAll是返回一个Girl对象组成的列表数据，所以要用List<Girl>
        return girlRepository.findAll();//通过实例来调用findAll()方法，返回数据库中所有的女生列表
    }

因为是REST模式来操作数据库
get是获取数据
post是新增数据
delete是删除数据
put是更新数据

27.对数据库进行事务操作的理解

事务
transactional
adj. 交易型的；事务性的；事务处理的
我的理解是，事务是一个整体，事务内可能包含多项数据库操作。但我们希望要么事务操作成功，要么事务整体失败，而不希望其中某些成功，某些失败。
所以我们把多项的数据库操作打包成一个事务，事务要么整体成功，要么整体失败。
只要在事务前添加@Transactional注解，就会把当前的这个方法注册成为事务

28.创建spring mvc项目

只要创建maven项目即可
maven中的依赖和插件等，直接照抄pom.xml

29.在src/main/resources下创建logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="1 seconds">

    <contextListener class="ch.qos.logback.classic.jul.LevelChangePropagator">
        <resetJUL>true</resetJUL>
    </contextListener>

    <jmxConfigurator/>

    <appender name="console" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>logbak: %d{HH:mm:ss.SSS} %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>

      <logger name="org.springframework.web" level="DEBUG"/> <!-- 1 -->
    <root level="info">
        <appender-ref ref="console"/>
    </root>
</configuration>

30.在src/main/resources/下创建视图目录views

通常是放到src/main/webapp/WEB-INF目录下的
但为了和spring boot相通

31.在views目录下创建首页

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>
    <pre>
        Welcome to Spring MVC world
    </pre>
</body>
</html>

32.创建spring mvc配置，渲染视图

/WEB-INF/classes/views/渲染后的视图会自动生成在此目录下

package com.yurencloud.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;

@Configuration
@EnableWebMvc
@ComponentScan("com.yurencloud.config")
public class MyMvcConfig {
    @Bean
    public InternalResourceViewResolver viewResolver(){
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/classes/views/");
        viewResolver.setSuffix(".jsp");
        viewResolver.setViewClass(JstlView.class);
        return viewResolver;
    }
}

33.如何实现jrebel和tomcat的自动热部署？

1.在Run的Edit Configuration中添加tomcat
2.在tomcat的development中选择artifact添加项目的war包
war包的选择，会有两个，一个带developer，开发的时候添加这个，就会有update classes and resources
如果没有developer的war包，可以在file--project structure中的artifact添加developer
如果选择普通的war包，那么只能热更新classes，不能热更新resources（视图和静态文件那些）
3.jrebel在tomcat下会自动热布署，不用按快捷键，但是对于容器的配置文件这些，都不会自动热部署，并且按快捷键也没用，必须要重启

34.创建java config的spring mvc步骤

1.创建配置文件 MyMvcConfig.java

@Configuration
@EnableWebMvc
@ComponentScan("com.yurencloud")
public class MyMvcConfig extends WebMvcConfigurerAdapter{
    @Bean
    public InternalResourceViewResolver viewResolver() {
        InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        viewResolver.setPrefix("/WEB-INF/views/");
        viewResolver.setSuffix(".jsp");
        viewResolver.setViewClass(JstlView.class);
        return viewResolver;
    }
}

2.创建初始化启动容器，并使用第一步的配置文件 WebInitializer.java

public class WebInitializer implements WebApplicationInitializer {//1

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext ctx = new AnnotationConfigWebApplicationContext();
        ctx.register(MyMvcConfig.class);
        ctx.setServletContext(servletContext); //2

        Dynamic servlet = servletContext.addServlet("dispatcher", new DispatcherServlet(ctx)); //3
        servlet.addMapping("/");
        servlet.setLoadOnStartup(1);
        servlet.setAsyncSupported(true);//1

    }

}

3.创建控制器

@Controller
public class HelloController {
    @RequestMapping("/")
    public String hello() {
        return "index";
    }
}

4.创建视图
这一步害我失败多次，主要原因是目录结构没弄清楚
视图一定要创建在
src
webapp
WEB-INF
views
index.jsp
我第一次总是创建在resources下，结果导致出问题

<%@ 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>
    <pre>
        Welcome to Spring MVC world
    </pre>
</body>
</html>

35.上传文件

1.添加依赖

        <!-- file upload -->
        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>
        <!-- 非必需，可简化IO操作 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.3</version>
        </dependency>

2.新建一个upload.jsp，并在MyMvcConfig中添加此视图的路由

<form action="upload"  //这里的action只要写相对路径就可以了

registry.addViewController("/toUpload").setViewName("upload");

3.在MyMvcConfig中添加MultipartResolver配置

    @Bean
    public MultipartResolver multipartResolver(){
        CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
        multipartResolver.setMaxUploadSize(10000000);
        return multipartResolver;
    }

4.控制器
目录我暂只知道写绝对路径，并且测试是成功的

package com.yurencloud.web;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

@Controller
public class UploadController {

    @RequestMapping(value = "/upload", method = RequestMethod.POST)
    public @ResponseBody
    String upload(MultipartFile file) {//1

        try {
            FileUtils.writeByteArrayToFile(new File("/Users/wanglecheng/Web/www/mack-wang/study/java/springmvc/src/main/resources/upload/" + file.getOriginalFilename()),
                    file.getBytes()); //2
            return "ok";
        } catch (IOException e) {
            e.printStackTrace();
            return "wrong";
        }
    }

}

36.服务器端推送技术

传统可以使用ajax向服务器发起轮询，但这样对服务器压力很大
以下是使用一种当客户端第一次向服务器发起请求时，服务器抓住该请求不放，直接有返回信息事件时，才返回响应，然后客户端再发起请求。这样可减轻服务器的压力。
SSE server send event 服务端发送事件
这里只有两个重点
一、produces="text/event-stream" 发送文件事件流
二、Thread.sleep(5000) 服务器处理该信息的线程每隔5秒返回一次信息

@Controller
public class SseController {
    @RequestMapping(value = "/push",produces = "text/event-stream")
    public @ResponseBody
    String push(){
        Random r = new Random();
        try{
            Thread.sleep(5000);
        }catch(InterruptedException e){
            e.printStackTrace();
        }
        return "data:Testing 1,2,3"+r.nextInt()+"\n\n";
    }
}

三,在jsp页面中用js使用sse技术（只有最新的浏览器才支持）

if(!!window.EventSource){
        var source = new EventSource('push');//向push这个路径发起请求
        s='';
        source.addEventListener('message',function (e) {
            s+=e.data+"<br/>";//监听message事件，每当服务器有文件信息返回时，就触发事件，然后返回事件信息e.data
            $("#msgFrompPush").html(s);
        });

        source.addEventListener('open',function (e) {
            console.log("链接打开");
        },false);

        source.addEventListener('error',function (e) {
            if(e.readyState == EventSource.CLOSED){
                console.log("连接关闭");
            }else{
                console.log(e.readyState);
            }
        },false);
    }else{
        console.log("你的浏览器不支持SSE");
    }

37.在jsp中引用静态文件

首先要引入标签库，前缀是c 我觉得是connect的意思

<%@taglib uri="http://java.sun.com/jstl/core" prefix="c" %>

使用c标签引入静态文件
<c:url value="assets/js/jquery.js"/> 等于 {{asset("/js/jquery.js")}}

<script type="text/javascript" src="<c:url value="assets/js/jquery.js"/>"></script>

38.处理异步请求

在WebInitializer中添加

servlet.setAsyncSupported(true);//这一句是开启异步支持的

控制器

@Controller
public class AysncController {
    @Autowired
    PushService pushService; //1

    @RequestMapping("/defer")
    @ResponseBody
    public DeferredResult<String> deferredCall() { //2
        return pushService.getAsyncUpdate();
    }

}

异步的服务(其实就是添加了一个@Scheduled，每5秒执行一次的任务调度)
这个DeferredResult是一个异步对象
import org.springframework.web.context.request.async.DeferredResult;

@Service
public class PushService {
    private DeferredResult<String> deferredResult;

    public DeferredResult<String> getAsyncUpdate() {
        deferredResult = new DeferredResult<String>();
        return deferredResult;
    }

    @Scheduled(fixedDelay = 5000)
    public void refresh() {
        if (deferredResult != null) {
            deferredResult.setResult(new Long(System.currentTimeMillis()).toString());
        }
    }
}

jsp中设置一个异步的循环调用

deferred();
    function deferred() {
        $.get('defer',function (data) {
            $("body").html(data);
            deferred();
        })
    }

39.创建spring mvc项目

1.创建pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yurencloud</groupId>
    <artifactId>springmvc2</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <commons-lang.version>2.6</commons-lang.version>
        <slf4j.version>1.7.6</slf4j.version>
        <spring.version>4.1.3.RELEASE</spring.version>
        <jackson.version>2.5.4</jackson.version>
    </properties>


    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-framework-bom</artifactId>
                <version>${spring.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
        </dependency>

        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>${commons-lang.version}</version>
        </dependency>


        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>${slf4j.version}</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.1</version>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>${jackson.version}</version>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.eclipse.jetty</groupId>
                <artifactId>jetty-maven-plugin</artifactId>
                <version>9.2.2.v20140723</version>
            </plugin>
        </plugins>
    </build>

</project>

2.创建web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
    http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
  <display-name>Spring MVC Study</display-name>
  
  <!-- DispatcherServlet, Spring MVC的核心 -->
  <servlet>
        <servlet-name>mvc-dispatcher</servlet-name>
        <servlet-class> org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- DispatcherServlet对应的上下文配置， 默认为/WEB-INF/$servlet-name$-servlet.xml
         -->
        <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>
        <!-- mvc-dispatcher拦截所有的请求-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

3.创建应用环境配置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.yurencloud.demo">
        <context:exclude-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>
</beans>

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">

    <!-- 本配置文件是工名为mvc-dispatcher的DispatcherServlet使用， 提供其相关的Spring MVC配置 -->

    <!-- 启用Spring基于annotation的DI, 使用户可以在Spring MVC中使用Spring的强大功能。 激活 @Required 
        @Autowired,JSR 250's @PostConstruct, @PreDestroy and @Resource 等标注 -->
    <context:annotation-config />

    <!-- DispatcherServlet上下文， 只管理@Controller类型的bean， 忽略其他型的bean, 如@Service -->
    <context:component-scan base-package="com.yurencloud.demo">
        <context:include-filter type="annotation"
            expression="org.springframework.stereotype.Controller" />
    </context:component-scan>

    <!-- HandlerMapping, 无需配置， Spring MVC可以默认启动。 DefaultAnnotationHandlerMapping 
        annotation-driven HandlerMapping -->

    <!-- 扩充了注解驱动，可以将请求参数绑定到控制器参数 -->
    <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>


    <!--200*1024*1024即200M resolveLazily属性启用是为了推迟文件解析，以便捕获文件大小异常 -->
    <bean id="multipartResolver"
        class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="209715200" />
        <property name="defaultEncoding" value="UTF-8" />
        <property name="resolveLazily" value="true" />
    </bean>
</beans>

5.创建控制器HelloController.java

package com.yurencloud.demo;

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

@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping("/mvc")
    public String helloMvc(){
        return "home";
    }
}

6.创建视图home.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>
Hello Spring MVC!
Here is iMooc!
</body>
</html>

40.目录结构

webapp
WEB-INF
configs
spring
applicationContext.xml
mvc-dispatcher-servlet.xml
jsps
home.jsp
web.xml
index.jsp

41.jetty默认是8080端口开启，所以如果tomcat也正在开启的话，会报错

42.生成并返回json和xml对象

在pom.xml中添加依赖

      <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-xml</artifactId>
            <version>2.5.3</version>
        </dependency>

@RestController是@Controller和@ResponseBody的组合注解
只返回数据，不返回页面

jackson做对象--json之间相互转换时，需要一个空构造器

package com.yurencloud.demo;


public class DemoObj {
    private Long id;
    private String name;
    
    //构造器，继承super()
    public DemoObj(){
        super();
    }
    public DemoObj(Long id,String name){
        super();
        this.id = id;
        this.name = name;
    }
    
    public Long getId() {
        return id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }


}

在控制器中使用 jackson转换json或xml，并返回该数据对象

@RestController //1
@RequestMapping("/rest")
public class DemoRestController {
    
    @RequestMapping(value = "/getjson",
            produces={"application/json;charset=UTF-8"}) //这里的produces是指返回的数据格式
    public DemoObj getjson (DemoObj obj){//返回的是经过
        return new DemoObj(obj.getId()+1, obj.getName()+"yy");//3
    }
    @RequestMapping(value = "/getxml",
            produces={"application/xml;charset=UTF-8"})//4
    public DemoObj getxml(DemoObj obj){
        return new DemoObj(obj.getId()+1, obj.getName()+"yy");
    }

}

43.对super，super(),super(param)的理解

super 是指向父类的指针，引用
class Children extends Father{
super.name; //这里的super和this用法一样，不过this指向Children，super指向父类Father
super(); //这里调用父类Father的无参构造器
super(param);//这里调用父类Father的只有一个param的有参构造器
}

44.使用了jrebel之后，就可以不用重启，直接按cmd+F9更新被修改过的文件。

45.如果关了当前容器，却忘记关掉jetty，则jetty会一直在后台执行，并占用8080端口，并且我们无法直接通过jetty:stop来关闭，解决方法

lsof -i:8080
kill 上面那一步找到的pid