一、基础理论
1、产生背景
SSM开发web应用配置复杂，springboot极大地简化了配置，让开发人员更多关注与业务逻辑的实现。
2、Springboot特性
A。能够快速创建基于spring的应用程序。
B。java main方法可启动内嵌的tomcat服务器来运行springboot程序，不需要部署war包文件。
C。起步依赖简化maven配置。
D。根据maven依赖自动配置spring、springmvc。
E。完全弃用XML配置，采用注解配置。
3、Springboot四大核心
自动配置：自动配置spring、springmvc。
起步依赖：起简化maven配置。
Actutor：健康检查，检测程序运行状况，一般用不到。
命令化界面：一般也用不到。
一般只用得到前两种。
4、springboot零碎知识点
resources目录下：
static:存放图片、js、cs等静态资源。
templates:存放前端模板。
application.properties:springboot核心配置文件。
SpringBootApplication:
springboot项目入口类中的核心注解，没有该注解，该入口类就是普通的java类。
注意：
springboot项目的所有代码类必须在入口类同级或下一级的目录位置。
5、springboot核心配置文件
可以是*.properties文件，也可以是*.yml(*.ymal)文件，都是键值对形式
两个同时存在，以*.properties为准
*.yml虽然也是键值对形式，但是书写格式还是有不同的，用到的时候百度
配置文件常用做法：
application-dev.properties:开发环境配置文件
application-tes.properties:测试环境配置文件
application-pro.properties:生产环境配置文件
然后在application.properties中设置：
spring.profiles.active=dev //表明当前生效的是开发环境的配置文件
6、自定义配置
A、将自定义配置映射到属性
aplication.properties中：
#自定义配置，将配置的属性自动注入到属性中
name=lily
age=18
代码中：
@Value("${name}") //自动注入配置文件的中name的值
private String name;
@Value("${age}") //自动注入配置文件的中age的值
private int age;
//获取自动注入的属性值，打印在前台
@RequestMapping(value="intro")
@ResponseBody
public String intro(){
return "I'm "+name+","+age+" years old!!";
}
B、将自定义配置映射到对象
aplication.properties中：
#自定义配置，将配置的对象属性自动注入到属性中
school.name=CAUC
school.address=Tianjin
对应配置类：
@Component //将此类交给Spring容器进行管理，方便诸如对象
@ConfigurationProperties(prefix = "school") //本类只读取配置文件中前缀为school的属性
public class School {
private String name;
private String address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
代码中：
@Autowired //自动注入对象
private School school;
//获取自动注入的对象的属性值，打印在前台
@RequestMapping(value="intro2")
@ResponseBody
public String intro2(){
return school.getName()+" is a university in "+school.getAddress();
}
7、注意事项
ConfigurationProperties警告：
在使用@ConfigurationProperties注解时，会报一个警告：
Spring Boot Configuration Annotation Processor not Configured。算该警告不影响运行，但看着烦，如何解决？？
解决方式，在pom.xml文件中添加如下依赖即可：
org.springframework.boot
spring-boot-configuration-processor
true
application.properties中文乱码问题 ：
见图片A
二、Springboot集成jsp
1、前置设置：
main-->new-->directory-->webapp(创建web资源文件夹)
file-->project structure-->modules-->找到该项目-->web-->将刚刚创建的webapp设置为web资源文件路径
具体见图B
2、添加jsp依赖
org.apache.tomcat.embed
tomcat-embed-jasper
3、指定jsp编译文件路径
在标签中添加：
src/main/webapp
META-INF/resources
*.*
4、设置SpringMC的视图解析器
aplication.properties中：
#配置springmvc的视图解析器
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp
webapp/show1.jsp文件：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
show1.jsp
${message}
webapp/show2.jsp文件：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
show2.jsp
${message}
代码中：
/*
视图解析器
*/
@RequestMapping(value="show1")
public ModelAndView show1(){//ModelAndView可以返回一个jsp页面，且可用来设置jsp内容
ModelAndView model=new ModelAndView();
model.addObject("message","hello,springboot");
model.setViewName("show1");
return model;
}
@RequestMapping(value="show2")
public String show2(Model model){
model.addAttribute("message","hello2,springboot");
return "show2";
}
三、springboot集成mybatis
1、修改pom.xml文件
mysql
mysql-connector-java
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.0.0
2、利用mybatis的逆向工程对单表生成实体bean、映射文件、mapper接口
在项目根目录新建文件GeneratorMapper.xml,添加如下内容：
在pom.xml文件中添加插件依赖：
org.mybatis.generator
mybatis-generator-maven-plugin
1.3.6
GeneratorMapper.xml
true
true
3、配置完成后在maven的plugins中找到mybatis-generator:generate并双击，即可生成实体类、映射文件和mapper接口。
见图3.1
4、生成的实体bean、mapper接口和映射文件
实体bean:
import java.util.Date;
public class Student {
private Integer sid;
private String sname;
private Date sage;
private String ssex;
public Integer getSid() {return sid;}
public void setSid(Integer sid) {this.sid = sid; }
public String getSname() {return sname;}
public void setSname(String sname) {this.sname = sname;}
public Date getSage() {return sage;}
public void setSage(Date sage) {this.sage = sage;}
public String getSsex() { return ssex;}
public void setSsex(String ssex) {this.ssex = ssex;}
}
mapper接口：
public interface StudentMapper {
int deleteByPrimaryKey(Integer sid);
/**
* 传入对象进行
* 修改和选择性修改
*
* @param record
* @return
*/
int insert(Student record);
int insertSelective(Student record);
Student selectByPrimaryKey(Integer sid);
/**
* 传入对象进行
* 更新和选择性更新
* @param record
* @return
*/
int updateByPrimaryKeySelective(Student record);
int updateByPrimaryKey(Student record);
}
映射文件StudentMapper.xml：
sid, sname, sage, ssex
select
delete from t_student
where sid = #{sid,jdbcType=INTEGER}
insert into t_student (sid, sname, sage,
ssex)
values (#{sid,jdbcType=INTEGER}, #{sname,jdbcType=VARCHAR}, #{sage,jdbcType=DATE},
#{ssex,jdbcType=CHAR})
insert into t_student
sid,
sname,
sage,
ssex,
#{sid,jdbcType=INTEGER},
#{sname,jdbcType=VARCHAR},
#{sage,jdbcType=DATE},
#{ssex,jdbcType=CHAR},
update t_student
sname = #{sname,jdbcType=VARCHAR},
sage = #{sage,jdbcType=DATE},
ssex = #{ssex,jdbcType=CHAR},
where sid = #{sid,jdbcType=INTEGER}
update t_student
set sname = #{sname,jdbcType=VARCHAR},
sage = #{sage,jdbcType=DATE},
ssex = #{ssex,jdbcType=CHAR}
where sid = #{sid,jdbcType=INTEGER}
5、注意事项
在java文件夹只能编译java文件，而mapper包下的mapper映射文件是配置文件，无法编译！
解决方案一：在pom.xml文件中的标签的子标签标签中添加：
src/main/java
**/*.xml
解决方案二：
在项目的resources下新建mapper文件夹并剪切移入所有的映射文件
然后再*.properties中配置：
mybatis.mapper-locations=classpath:mapper/*.xml
两种方式都很常用
四、SpringBoot集成Mybatis示例
1、pom.xml文件
pom.xml文件
4.0.0
org.springframework.boot
spring-boot-starter-parent
2.3.1.RELEASE
com.farben.unit
springunit
0.0.1-SNAPSHOT
1.8
org.springframework.boot
spring-boot-starter-web
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
org.springframework.boot
spring-boot-configuration-processor
true
org.apache.tomcat.embed
tomcat-embed-jasper
mysql
mysql-connector-java
org.mybatis.spring.boot
mybatis-spring-boot-starter
2.0.0
src/main/java
**/*.xml
src/main/webapp
META-INF/resources
*.*
org.springframework.boot
spring-boot-maven-plugin
org.mybatis.generator
mybatis-generator-maven-plugin
1.3.6
GeneratorMapper.xml
true
true
2、application.properties文件
#给内置tomcat配置端口
server.port=8090
#设置上下文根,访问servlet别名前需加/s
server.servlet.context-path=/s
#配置数据库连接 mysql8的驱动名称变了，是com.mysql.cj.jdbc.Driver
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/d_student?useUnicode=true&characterEncoding=UTF-8&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=GMT%2B8
spring.datasource.username=root
spring.datasource.password=1234563、GeneratorMapper.xml文件
4、代码
控制层Controller
@Controller
public class StudentController {
@Autowired //注入service层对象
private StudentService service;
@RequestMapping(value="stu")
@ResponseBody
public Object getOneStudent(Integer id){
Student student=service.getStudentById(id);
return student;
}
}
业务层service
public interface StudentService {
Student getStudentById(Integer id);
}
@Service //扫描service到spring容器，便于自动注入对象
public class StudentServiceImpl implements StudentService {
@Autowired //自动注入mapper层对象
private StudentMapper mapper;
@Override
public Student getStudentById(Integer id) {
return mapper.selectByPrimaryKey(id);
}
}
model层：自动生成
mapper层：自动生成
只是mapper接口需要添加@Mapper注解即可
如下图：
@Mapper //扫描mapper接口到spring容器，便于自动注入对象
public interface StudentMapper {
int deleteByPrimaryKey(Integer sid);
int insert(Student record);
int insertSelective(Student record);
Student selectByPrimaryKey(Integer sid);
int updateByPrimaryKeySelective(Student record);
int updateByPrimaryKey(Student record);
}
注意：
mapper层注解卸载接口上，service层注解卸载实现类上。
注意事项：
如果是多表查询，则必然有多个mapper接口，每个mapper接口都手动添加@Mapper注解，很繁琐
解决：
所有mapper接口均不需要添加@Mapper注解
改为在springboot启动入口程序类上添加:
@MapperScan(basePackages = "com.farben.springboot.mapper")
指定需要扫描的mapper包的具体路径，此后该mapper包下所有类都可以使用注解@Autowired自动注入对象。
5、补充springboot事务
只需要在Service实现类的增删改方法上增加一个@Transactional注解即可。
注意：
在springboot2.0版本之前，还需要在入口类上添加@EnableTransactionManagement注解来开启事务。
示例：
@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentMapper mapper;
@Override
@Transactional // 开启事务并自动提交 10/0失败，则查询也会失败
public Integer updateByid(Student student) {
Integer result=mapper.updateByPrimaryKeySelective(student);
Integer i=10/0;
return result;
}
}五、SpringBoot集成SpringMVC
1、新建好一个springboot项目，其实就集成好了SpringMVC。
2、SpringMVC自定义视图解析器，见SpringBoot集成JSP。
3、SpringMVC核心注解
@Controller:
表名该类是控制层，用于处理http请求。
@ResponseBody:
表名该方法返回一个json字符串。
@RestController:
表名该controller类下所有方法都返回一个json字符串。
@RequestMapping:
表名该方法可用来处理GET和post请求。用来给servlet起别名。
@GetMapping:
表名该方法可用来处理GET请求。用来给servlet起别名。
@PostMapping:
表名该方法可用来处理POST请求。用来给servlet起别名。
注意：
从浏览器地址栏发的请求都是GET请求，要发post请求可以使用postman客户端。
还有两个用得不多的注解：
@DeleteMapping:
表名该方法可用来处理DELETE请求。用来给servlet起别名。
@PutMapping:
表名该方法可用来处理PUT请求。用来给servlet起别名。
六、Springboot实现RESTful
1、RESTful是一种软件设计风格，一个架构只要符合RESTful原则，责成其为RESTful架构。
说白了就是在浏览器地址栏以路径的方式传参。
2、示例
访问一个接口的HTTP地址：http://localhost:8090/s/stu?id=3
RESTful风格的HTTP地址：http://localhost:8090/s/stu/3
而在Controller层的servlet方法中：
/**
* RESTful
* 原则一：
* 新增用PostMapping，删除用DeleteMapping，修改用PutMapping，查询用GetMappring
* 这样的话如果增删改都要传sid和sname参数
* 当都通过http://localhost:8090/s/stu/info/1/赵雷 访问，可以通过请求方式加以区别
* 当然，如果有两个相同的删除方法，所需要的参数也一致，则可以调整参数位置加以区别
* 如下：
* stu/info/{sid}/{sname}
* stu/{sid}/info/{sname}
*原则二：
* RESTful方式访问时参数最好都是数据库表字段，非数据库表字段用传统问号拼接即可
*
*/
@GetMapping(value="stu/info/{sid}/{sname}")
@ResponseBody
public Object getName(@PathVariable("sid") Integer sid,@PathVariable("sname") String sname){
return "sid:"+sid+"-sname:"+sname;
}
七、Springboot集成Redis
1、在pom.xml中添加redis依赖
org.springframework.boot
spring-boot-starter-data-redis
2、在*.properties中添加redis配置信息
spring.redis.host=localhost
spring.redis.port=6379
spring.redis.password=123456
3、插入获取redis数据示例
见图11.1、11.2
八、SpringBoot集成Dubbo
1、需要三个modual,一个为接口工程，一个为服务提供者，一个为服务消费者。
接口工程：存放实体bean和业务接口。
maven工程：dubbo-interfaces
服务提供者：存放业务接口的实现类，并将服务注册到服务中心，调用数据持久层。
springboot web工程：dubbo-providers
服务消费者：从注册中心调用服务提供者提供的服务，来处理浏览器发出的请求。 springboot web工程
springboot web工程：dubbo-consumers
2、配置
A、添加依赖（服务者和消费者都需要添加）
com.alibaba.spring.boot
dubbo-spring-boot-starter
2.0.0
com.101tec
zkclient
0.11
com.farben.springboot
dubbo-interfaces
1.0.0
B、修改application.properties配置文件
服务提供者：
#内置tomcat端口
server.port=8091 #别和服务消费者一样
#设置上下文根
server.servlet.context-path=/s
#dubbo的配置
spring.application.name=dubbo-providers
#声明当前项目是服务提供者
spring.dubbo.server=true
spring.dubbo.registry=zookeeper://127.0.0.1:2181
服务消费者：
#内置tomcat端口
server.port=8090
#设置上下文根
server.servlet.context-path=/s
#dubbo的配置
spring.application.name=dubbo-consumers
#注册中心
spring.dubbo.registry=zookeeper://127.0.0.1:2181
C、注册中心
一般使用zookeeper,可以在windows上搭建一个单节点的即可。
下载地址：https://archive.apache.org/dist/zookeeper/zookeeper-3.4.11/zookeeper-3.4.11.tar.gz
解压后，拷贝配置文件为zoo.cfg，并修改dataDir属性为自定义的目录，然后在bin下情动zkServer.cmd即可。
3、代码书写
dubbo-consumers：
Controller:
@Controller
public class StudentController {
/**
* Reference注解是dubbo的注解，别导错了
* 表明要从注册中心引用已经暴露的服务，即StudentService.class
*/
@Reference(interfaceClass = StudentService.class,version="1.0.0",check=false)
private StudentService service;
@RequestMapping(value="dubbo/{id}")
@ResponseBody
public Object getOneStudent(@PathVariable("id") Integer id){
return service.getOneStudent(id);
}
}
dubbo-interfaces:
Service:
public interface StudentService {
Object getOneStudent(Integer id);
}
dubbo-providers:
Service.impl
@Component //将类加入spring容器
//将服务暴露给注册中心。这是dubbo的注解，别导错了
@Service(interfaceClass = StudentService.class,version = "1.0.0",timeout = 10000)
//父接口类对象、版本、超时时间
public class StudentServiceImpl implements StudentService {
@Override
public Object getOneStudent(Integer id) {
return 12;
}
}
3、三个注解
@EnableDubboConfiguration 在服务提供者和服务消费者的入口程序上添加，表明开启dubbo配置。
@Service dubbo的注解，别导错了。在业务接口上添加，将服务暴露给注册中心。
@Reference dubbo的注解，别导错了。在控制层上使用表明从注册中心引用服务。
4、注意事项:
在dubbo-providers和dubbo-consumers的springboot入口类上都需要加入@EnableDubboConfiguration注解来开启dubbo的配置
启动时zkServer.cmd,再启动dubbo-providers，最后启动dubbo-consumers。
Dubbo要求实体类bean需要实现序列化接口。
九、Springboot使用拦截器
1、拦截器和过滤器
过滤器拦截的是servlet,而在springmvc之后，只剩下一个公有的servlet，原本的多个servlet已有多个单元
方法替代，而拦截器拦截的就是这些单元方法。
过滤器在servlet之前，而拦截器在servlet之后，单元方法之前。
2、拦截器配置
A、自定义的拦截器类需要实现HandlerInterceptor接口，重写preHandle方法，在方法中定义拦截器规则。
B、需要一个配置类，配置类使用@Configuration声明，并实现WebMvcConfigurer接口，重写
addInterceptors方法，在方法中定义拦截器拦截范围。
3、代码示例
model:
@Component
public class User {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
}
interceptor:
/**
* 拦截器，定义拦截器规则
* 实现HandlerInterceptor接口，重写preHandle
* 并在preHandle方法中定义
* session中有user,则返回true。直接访问
* 没有user,则重定向/user/error，返回false
*/
public class UserLoginInterceptor implements HandlerInterceptor {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
User user=(User)request.getSession().getAttribute("user");
if(user==null){
response.sendRedirect(request.getContextPath()+"/user/error");
return false;
}
return true;
}
}
config:
/**
* 拦截器配置类，定义拦截器拦截范围
* addPathPatterns表明拦截的范围 假设为为【1，5】
* excludePathPatterns表名在要拦截的范围中排除的范围 假设为2，3
* 则真正拦截范围为1，4，5
* /user/** 代表只要开头为/user,后面随便是什么，随便有多少级子目录
* /user/* 代表只要开头为/user,后面随便是什么，只有一级子目录
*/
@Configuration
public class UserConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
String [] addPathPatterns={
"/user/**"
};
String [] excludePathPatterns={
"/user/login","/user/error"
};
registry.addInterceptor(new UserLoginInterceptor()).
addPathPatterns(addPathPatterns).
excludePathPatterns(excludePathPatterns);
}
}
controller:
@Controller
@RequestMapping(value="/user")
public class UserLoginInterceptorTest {
@Autowired
private User user;
//登陆的方法，不登陆也可访问
@RequestMapping(value="/login")
public @ResponseBody String login(HttpServletRequest req){
req.getSession().setAttribute("user",user);
return "login succeed!";
}
//登陆后才能访问的方法
@RequestMapping(value="/center")
public @ResponseBody String center(){
return "after login succeed,you can enter the center area!";
}
//登陆失败跳转的方法，不登陆也可访问
@RequestMapping(value="/error")
public @ResponseBody String error(){
return "you must login first!!";
}
}
十、Springboot程序打包
1、打包分类
打包其实可以打jar包，也可以打war包。一般打jar包居多。
2、区别
jar:
是springboot应用程序默认的打包方式。
jar包运行不依赖外置tomcat。
.properties文件中的端口号等配置会生效。
浏览器访问启动的jar不需要在路径中添加jar包名称。
war:
需要在pom文件中通过war 启用war包打包方式。
war包运行依赖外置的tomcat服务器，war包需要放在tomcat的wabapps目录下。
.properties文件中的端口号等配置不会生效。
浏览器访问启动的war需要在路径中添加war包名称。
3、打jar包的配置
firstSpringBootJar
src/main/resources
**/*.*
org.springframework.boot
spring-boot-maven-plugin
1.4.2.RELEASE
配置完成先clean再package,然后将target下的jar包copy出来，放到任意地方，通过cmd运行“java -jar
jar包名.jar”即可运行springboot程序，打开浏览器访问即可。不需要加Jar包名。
4、打war包的配置
war
firstSpringBootWar
src/main/resources
**/*.*
修改入口类
@SpringBootApplication
public class SpringbootApplication extends SpringBootServletInitializer {
public static void main(String[] args) {
SpringApplication.run(SpringbootApplication.class, args);
}
/**
* 打jar包必须有这方法
* @param builder
* @return
*/
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(SpringbootApplication.class);
}
}
配置完成先clean再package,然后将target下的war包copy出来，放到tomcat的webapps目录下，返回
tomcat的bin目录双击startup.bat即可运行springboot程序，打开浏览器访问即可。需要加War包名。
十一、Springboot集成logback日志
1、基础
logback实际上是第三版的log4j,是最新的。
日志级别有低到高：trcae
org.projectlombok
lombok
在resources下新建logback-spring.xml文件
debug
%date [%-5p] [%thread] %logger{60} {%file : %line} %msg%n
UTF-8
D:/springboot.log
%date [%-5p] [%thread] %logger{60} {%file : %line} %msg%n
UTF-8
D:/springboot.log.%d{yyyy-MM-dd}.log
15
注意：
代码中使用logger.info()等代码，该类还必须添加@Slf4j注解。 十二、关闭/修改springboot工程启动logo
1、关闭logo
直接上代码
@SpringBootApplication
public class SpringbootApplication {
public static void main(String[] args) {
/**
* 关闭springboot 启动logo
*/
SpringApplication spring=new SpringApplication(SpringbootApplication.class);
spring.setBannerMode(Banner.Mode.OFF);
spring.run(args);
}
}
2、修改logo
A、访问
https://www.bootschool.net/ascii
或
http://patorjk.com/software/taag/
输入文字，获得想要更改的logo图样，拷贝下来。
B、在resources文件夹下创建banner.txt文件
将复制下来的logo拷贝到该文件保存启动程序即可看到自定义的logo。
文件名必须叫banner.txt
十三、springboot使用过滤器
1、过滤器配置
第一种方式：
A、自定义过滤器用@WebFilter(urlPatterns = "过滤路径") 标注，实现Filter接口，复写doFilter方法。
B、入口类用@ServletComponentScan(basePackages = "com.farben.springboot.filter")标准，配置被扫描的过滤器路径。
第二种方式：
A、自定义过滤器实现Filter接口，复写doFilter方法。
B、自定义配置类，加@Configuration标注，在类中自定义方法，方法中注册过滤器，添加过滤路径，并返回这个过滤器。
2、第一种方式代码
filter:
@WebFilter(urlPatterns = "/user") //过滤掉“/user”
public class MyFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("进入自定义过滤器");
chain.doFilter(request,response);
}
}
controller:
@Controller
public class MyFilterTest {
@RequestMapping(value="/user")
public @ResponseBody String user(){
return "user info show over!!";
}
@RequestMapping(value="/stu")
public @ResponseBody String stu(){
return "can't come in filter";
}
}
入口类：
@SpringBootApplication
@ServletComponentScan(basePackages = "com.farben.springboot.filter") //servlet扫描路径
public class SpringbootFilterApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootFilterApplication.class, args);
}
}
3、第二种方式代码
filter:
public class MyFilter implements Filter {
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
System.out.println("欢迎进入过滤器");
chain.doFilter(request,response);
}
}
配置类config
@Configuration //定义为配置类
public class MyFilterConfig {
@Bean
public FilterRegistrationBean myFilterRegistration(){
//注册过滤器
FilterRegistrationBean myFilter = new FilterRegistrationBean(new MyFilter());
//添加过滤器路径
myFilter.addUrlPatterns("/user");
return myFilter;
}
}
controller:
@Controller
public class MyFilterTest {
@RequestMapping(value="/user")
public @ResponseBody
String user(){
return "user info show over!!";
}
@RequestMapping(value="/stu")
public @ResponseBody String stu(){
return "can't come in filter";
}
}
入口类：
@SpringBootApplication
public class SpringbootFilter2Application {
public static void main(String[] args) {
SpringApplication.run(SpringbootFilter2Application.class, args);
}
}
十四、SpringBoot创建java工程
1、和springboot web工程区别
创建时：勾选web后不要勾选spring web。
创建后：resources下没有static、templates等静态资源文件夹，且pom文件在的web工程起步依赖变成了非web工程起步依赖。
2、获取容器内对象
因为没有web工程的依赖，那么如何获取通过@Service、@Component等注解加入Spring容器的对象？
有两种方式，见以下示例：
第一种方式：
@SpringBootApplication
public class SpringbootJavaApplication {
public static void main(String[] args) {
/**
* 入口类启动后返回一个ConfigurableApplicationContext对象，该对象也是spring的容器
* 可以通过该对象的getBean("对象所属类名首字母小写")来获取
* 通过@Service、@Component等注解spring容器对象。
*/
ConfigurableApplicationContext cac= SpringApplication.run(SpringbootJavaApplication.class, args);
StudentServiceImpl service=(StudentServiceImpl) cac.getBean("studentServiceImpl");
System.out.println(service.welcomeSpringbootJava("welcome to springboot java application!"));
Student student=(Student) cac.getBean("student");
student.setSname("张三");
System.out.println(student.getSname());
}
}
第二种方式：
@SpringBootApplication
public class SpringbootJava2Application implements CommandLineRunner { //第一步，实现CommandLineRunner接口
//第二步，在注入对象上加入@Autowired注解
@Autowired
private StudentService service;
@Autowired
private Student student;
public static void main(String[] args) {
SpringApplication.run(SpringbootJava2Application.class, args);
}
@Override
public void run(String... args) throws Exception { //重写run方法
System.out.println(service.welcomeSpringbootJava("welcome to springboot java application!"));
student.setSname("张三");
System.out.println(student.getSname());
}
}
3、其实springboot创建非web应用没什么软用，不如直接创建maven java工程呢。
所以这一部分仅作了解即可。
十五、springboot使用servlet
第一步：
自定义servlet用@WebServlet标注，实现HttpServlet接口，在doGet或doPost方法中实现servlet逻辑。
第二步（有两种实现方式）：
第一种：
入口类用@ServletComponentScan标注。
第二种：
自定义配置类，在配置类中配置自定义好的servlet。
注意：
用得不多，用到再百度即可。
