Springboot
1.springboot的引言
Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要定义样板化的配置。通过这种方式,Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。
springboot=spring+springmvc
2.springboot相关的特点
- 创建独立的spring应用
- 内嵌的tomcat,所以不需要再次部署
- 简化maven配置
- 自动配置
xml | @Confirguation |
---|---|
bean | @bean |
注意:
java配置@Confirguation注解加在类上,表示当前类为配置类
@bean加在方法上表示当前方法返回值是需要交由工厂管理的对象,方法名就是对象的名字
3.springboot的约束
src/main/java
com.baizhi
entity
dao
service
Application.java 必须放置在主包内和子包同级
src/main/resources
application.yml
application.yaml
application.properties
配置文件放置在resources目录,名字必须叫application
src/test/java
src/test/resources
4.springboot的两种环境搭建形式
1.maven形式搭建
1.引入依赖
<!--继承springboot的父项目-->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.5.7.RELEASE</version>
</parent>
<dependencies>
<!--引入springboot的web支持-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
</dependencies>
2.创建入口类
@SpringBootApplication
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class,args);
}
}
3.写配置文件
4.测试
@RestController
@RequestMapping("/test")
public class UserController {
@RequestMapping("/test")
public String test(){
return "hello springboot";
}
}
2.springboot使用插件进行环境搭建
1.选择插件
2.勾选必要依赖
3.修改springboot的版本号
修改springboot的jar版本为1.5.7
3.相关注解的介绍
- SpringbootApplication
@ComponentScan(basePackages = "com.baizhi.*")
@Configuration
@EnableAutoConfiguration
/*
* 组合注解:一个注解包含多个注解的功能
* @SpringBootApplication=@Configuration+@ComponentScan+@EnableAutoConfiguration
* @Configuration:加在类上声明当前类 为配置类
* @ComponentScan:组件扫描,将扫描到的类交由工厂管理
* @Repository
@Component
@Service
@Controller
@EnableAutoConfiguration:开启自动配置,一旦引入第三方的jar,springboot就可以帮你配制相关组件
*
* */
- RestController
/*
* 组合注解@RestController=@Controller+ @ResponseBody
* 加在控制器类上表明当前类是控制器对象,并且返回json
*
* springboot默认的视图层模板不是jsp thymeleaf
* */
5.springboot和第三方技术的集成
1.springboot和mybatis集成
1.导入依赖
<!--mybatis相关jar springboot和mybatis的整合jar封装了mybatis-->
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.3.3</version>
</dependency>
<!--mysql的驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<!--阿里数据源-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
2.配置文件配置
#数据源类型 以及参数
spring:
datasource:
url: jdbc:mysql://localhost:3306/springboot
driver-class-name: com.mysql.jdbc.Driver
username: root
password: root
type: com.alibaba.druid.pool.DruidDataSource
#mybatis相关配置 别名 mapper位置
mybatis:
type-aliases-package: com.baizhi.entity
mapper-locations: classpath:com/baizhi/mapper/*Mapper.xml
3.入口类相关配置
@SpringBootApplication
//指定dao位置从而创建dao的动态代理类
@MapperScan(basePackages = "com.baizhi.mapper")
public class App {
public static void main(String[] args) {
SpringApplication.run(App.class,args);
}
}
2.spirngboot整合jsp
1.导入jar和插件
<!--内嵌tomcat支持的jar-->
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
</dependency>
<!--整合jsp以插件形式启动-->
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<dependency>
<groupId>jstl</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
2.配置视图解析器
spring:
mvc:
view:
prefix: /
suffix: .jsp
#热部署
server
jsp-servlet:
init-parameters:
development: true
3.logback
1.日志的级别:debug—info—warn–error 日志级别越低打印日志量越多,越详细
2.日志的分类: 父日志(根日志) 控制全局日志
子日志 某个包中的日志 子日志优先级高于父日志
3.Appender 为日志输出目的地,Log4j提供的appender有以下几种:
org.apache.log4j.ConsoleAppender(控制台),
org.apache.log4j.FileAppender(文件),
org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件),
org.apache.log4j.RollingFileAppender(文件大小到达指定尺寸的时候产生一个新的文件),
org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方)
4.Layout:日志输出格式,Log4j提供的layout有以下几种
org.apache.log4j.HTMLLayout(以HTML表格形式布局),
org.apache.log4j.PatternLayout(可以灵活地指定布局模式),
org.apache.log4j.SimpleLayout(包含日志信息的级别和信息字符串),
org.apache.log4j.TTCCLayout(包含日志产生的时间、线程、类别等等信息)
5.打印参数: Log4J采用类似C语言中的printf函数的打印格式格式化日志信息,如下:
%m 输出代码中指定的消息
%p 输出优先级,即DEBUG,INFO,WARN,ERROR,FATAL
%r 输出自应用启动到输出该log信息耗费的毫秒数
%c 输出所属的类目,通常就是所在类的全名
%t 输出产生该日志事件的线程名
%n 输出一个回车换行符,Windows平台为“\r\n”,Unix平台为“\n”
%d 输出日志时间点的日期或时间,默认格式为ISO8601,也可以在其后指定格式,比如:%d{yyy MMM dd HH:mm:ss ,SSS},输出类似:2002年10月18日 22 : 10 : 28 , 921
%l 输出日志事件的发生位置,包括类目名、发生的线程,以及在代码中的行数。举例:
Testlog4.main(TestLog4.java: 10 )
2.logback
//命名必须为logback.xml然后放置在resources目录
<?xml version="1.0" encoding="UTF-8" ?>
<configuration>
<appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
<layout class="ch.qos.logback.classic.PatternLayout">
<pattern> [%p] [%d{yyyy-MM-dd HH:mm:ss}] %m %n</pattern>
</layout>
</appender>
<root level="info">
<appender-ref ref="stdout"/>
</root>
<logger name="com.baizhi.mapper" level="DEBUG"/>
</configuration>
1.使用日志
//构建logger对象
private static Logger logger= LoggerFactory.getLogger(UserServiceImpl.class);
//自定义日志
logger.debug("this is debug");
logger.info("this is info");
logger.warn("this is warn");
logger.error("this is error");
4.lombok
1.在idea中安装lombok插件
2.引入lombok的jar
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.6</version>
<scope>provided</scope>
</dependency>
3.相关注解
@Accessors(chain = true) 用在类上支持set方法的链式调用
@AllArgsConstructor 用在类上提供全参构造
@Data 用在类上提供get set tostring noargs hashcode and equals
@Getter 用在类上提供get
@Setter 用在类上提供set
@AllArgsConstructor
@NoArgsConstructor
@ToString
@EqualsAndHashCode
6.自动配置的原理
1.spring中的属性注入
1.构建配置文件
构建配置文件 jdbc.properties
jdbc.url=jdbc:mysql://localhost:3306/springboot
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.userName=root
jdbc.password=root
2.书写配置类完成属性注入
@PropertySource(value = "classpath:/jdbc.properties")
public class JavaConf {
@Value("${jdbc.url}")
public String url;
@Value("${jdbc.password}")
public String password;
@Value("${jdbc.userName}")
public String userName;
@Value("${jdbc.driverClassName}")
public String driverClassName;
}
2.springboot中的属性注入
1.在默认的application配置文件中加入相关参数
server.port=8989
jdbc.url=jdbc:mysql://localhost:3306/springboot
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.userName=root
jdbc.password=root
2.书写属性类
@ConfigurationProperties(prefix = "jdbc")
public class JdbcProp {
private String url;
private String userName;
private String password;
private String driverClassName;
}
3.在配置类中注入属性类
@EnableConfigurationProperties(value = JdbcProp.class)
@Configuration
public class JavaConf {
@Autowired
JdbcProp jdbcProp;
@Bean
public DruidDataSource getDruidDataSource() {
DruidDataSource druidDataSource = new DruidDataSource();
druidDataSource.setUrl(jdbcProp.getUrl());
druidDataSource.setUsername(jdbcProp.getUserName());
druidDataSource.setPassword(jdbcProp.getPassword());
druidDataSource.setDriverClassName(jdbcProp.getDriverClassName());
return druidDataSource;
}
}
总结:springboot在加载工厂的过程中,优先加载启动器中的相关代码,将相关的对象交由工厂管理,如果想动态的修改对象相关属性,可以采用属性注入的方式完成
7.springboot中的细节
1.测试
1.引入jar
//已经封装了junit 不需要再引入junit的jar
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
2.创建测试类
@SpringBootTest(classes =App.class) //声明是springboot的测试类 并且指定入口类
@RunWith(SpringRunner.class) //在工厂环境下启动测试
public class UserTest {
@Autowired
UserMapper userMapper;
@Test
public void testUser(){
List<User> users = userMapper.queryAll();
for (User user : users) {
System.out.println(user);
}
}
}
2.配置文件的切分
3.编码过滤器
乱码:get请求乱码,springboot内嵌tomcat为utf-8
post请求乱码
springboot启动器中配置
@Bean
@ConditionalOnMissingBean({CharacterEncodingFilter.class})
public CharacterEncodingFilter characterEncodingFilter() {
CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
filter.setEncoding(this.properties.getCharset().name());
filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
return filter;
}
spring
http:
encoding:
charset: utf-8
force: true
4.文件上传
@ConditionalOnMissingBean({MultipartResolver.class})
public StandardServletMultipartResolver multipartResolver() {
StandardServletMultipartResolver multipartResolver = new StandardServletMultipartResolver();
multipartResolver.setResolveLazily(this.multipartProperties.isResolveLazily());
return multipartResolver;
}
spring:
http:
multipart:
#单个文件的最大值
max-file-size: 10Mb
#一次请求的最大值
max-request-size: 100MB
5.热部署
1.引入jar
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<version>1.5.7.RELEASE</version>
</dependency>
2.修改idea为自动编译
3.修改idea的类交换
5.jar包部署
jar包部署注意两点,第一点是将webapp打包到MET-inf,第二点是使用1.4.2的spring-boot-maven-plugin
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<version>1.4.2.RELEASE</version>
<configuration>
<mainClass>com.baizhi.App</mainClass>
<layout>JAR</layout>
</configuration>
</plugin>
</plugins>
<resources>
<!-- 打包时将jsp文件拷贝到META-INF目录下-->
<resource>
<!-- 指定resources插件处理哪个目录下的资源文件 -->
<directory>src/main/webapp</directory>
<!--注意此次必须要放在此目录下才能被访问到-->
<targetPath>META-INF/resources</targetPath>
<includes>
<include>**/**</include>
</includes>
</resource>
<resource>
<!-- 打包时不把配置文件打包到META-INF目录下-->
<directory>src/main/resources</directory>
<includes>
<include>**/**</include>
</includes>
<filtering>false</filtering>
</resource>
<!-- 打包时不把class文件打包到META-INF目录下-->
<resource>
<directory>src/main/java</directory>
<excludes>
<exclude>**/*.java</exclude>
</excludes>
</resource>
</resources>
6.fastjson和springboot集成
8.springboot中的aop编程
1.注解式aop的编程思路
1.引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
<version>1.5.7.RELEASE</version>
</dependency>
2.开发切面通知切入点
@Pointcut(value = "execution(* com.baizhi.service.*.*(..))")
public void pt(){
}
// @Before("pt()")
// public void testBefore(JoinPoint joinPoint){
// //目标方法对象
// Signature signature = joinPoint.getSignature();
// //目标方法参数列表
// Object[] args = joinPoint.getArgs();
// //目标对象
// Object target = joinPoint.getTarget();
// System.out.println(signature);
// System.out.println(args);
// System.out.println(target);
//
// System.out.println("this is before advice");
// }
//
//
//
// @After("pt()")
// public void testAfter(JoinPoint joinPoint){
// //目标方法对象
// Signature signature = joinPoint.getSignature();
// //目标方法参数列表
// Object[] args = joinPoint.getArgs();
// //目标对象
// Object target = joinPoint.getTarget();
// System.out.println(signature);
// System.out.println(args);
// System.out.println(target);
//
// System.out.println("this is after advice");
// }
@Around("pt()")
public Object testAround(ProceedingJoinPoint proceedingJoinPoint){
Object proceed=null;
try {
//作用 放行执行目标方法 返回值是目标方法的返回值
proceed = proceedingJoinPoint.proceed();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
return proceed;
}
}