java学习笔记汇总

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

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

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

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

添加此依赖

        
            org.springframework.boot
            spring-boot-devtools

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

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

        
            org.springframework.boot
            spring-boot-devtools
            true//这点
        
    

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    true

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
引入依赖

        
            javax.annotation
            jsr250-api
            1.0

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

8.事件 Application Event

DemoEvent 继承ApplicationEvent接口,创建事件
DemoListener 继承ApplicationListener接口，并传入事件类型，接收处理
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: 
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 findAll(Pageable pageable);

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

@GetMapping(value = "/admin/page/{id}")
    public Page 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.添加依赖

        
            org.springframework.boot
            spring-boot-starter-data-rest

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其中的一种实现

        
            org.springframework.boot
            spring-boot-starter-data-jpa
        

        
            mysql
            mysql-connector-java

在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{
}

查询数据库

    @Autowired//注入model
    private GirlRepository girlRepository;

    @GetMapping(value = "girls")
    public List getList(){//因为findAll是返回一个Girl对象组成的列表数据，所以要用List
        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




    
        true
    

    

    
        
            logbak: %d{HH:mm:ss.SSS} %logger{36} - %msg%n

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




Insert title here


            Welcome to Spring MVC world

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




Insert title here


            Welcome to Spring MVC world

35.上传文件

1.添加依赖

        
        
            commons-fileupload
            commons-fileupload
            1.3.1
        
        
        
            commons-io
            commons-io
            2.3

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

 
 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+"
";//监听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标签引入静态文件
  等于 {{asset("/js/jquery.js")}} 
  
 
 
 38.处理异步请求 
  
  在WebInitializer中添加 
  
 servlet.setAsyncSupported(true);//这一句是开启异步支持的
 
  
  控制器 
  
 @Controller
public class AysncController {
    @Autowired
    PushService pushService; //1

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

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

    public DeferredResult getAsyncUpdate() {
        deferredResult = new DeferredResult();
        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 
  
 

    4.0.0

    com.yurencloud
    springmvc2
    1.0-SNAPSHOT

    
        2.6
        1.7.6
        4.1.3.RELEASE
        2.5.4
    


    
        
            
                org.springframework
                spring-framework-bom
                ${spring.version}
                pom
                import
            
        
    

    
        
            org.springframework
            spring-webmvc
        

        
            commons-lang
            commons-lang
            ${commons-lang.version}
        


        
            org.slf4j
            slf4j-log4j12
            ${slf4j.version}
            
                
                    slf4j-api
                    org.slf4j
                
            
        

        
            org.slf4j
            slf4j-api
            ${slf4j.version}
        

        
            javax.servlet
            servlet-api
            2.5
        

        
            commons-fileupload
            commons-fileupload
            1.3.1
        

        
            com.fasterxml.jackson.core
            jackson-databind
            ${jackson.version}
        

    

    
        
            
                org.eclipse.jetty
                jetty-maven-plugin
                9.2.2.v20140723
            
        
    


 
  
  2.创建web.xml 
  
 

  Spring MVC Study
  
  
  
        mvc-dispatcher
         org.springframework.web.servlet.DispatcherServlet
        
        
          contextConfigLocation
          /WEB-INF/configs/spring/mvc-dispatcher-servlet.xml
        
        1
    
    
        mvc-dispatcher
        
        /
    

 
  
  3.创建应用环境配置applicationContext.xml 
  
 


    

    
        
    

 
  
  4.创建路由配置mvc-dispatcher-servlet.xml 
  
 


    

    
    

    
    
        
    

    

    
    

    
        
        
        
    


    
    
        
        
        
    

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




Insert title here


Hello Spring MVC!
Here is iMooc!


 
 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中添加依赖 
       
            com.fasterxml.jackson.dataformat
            jackson-dataformat-xml
            2.5.3
        
 
 @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