Springboot框架笔记

SpringBoot框架

一、SpringBoot概述

相当于是对Spring进行的封装，虽然在功能上没有进行扩展，但是能够快速构建Spring功能，以及能够简化开发

1、SpringBoot特性

1.SpringBoot并不是对Spring功能上的增强，而是提供了一种快速创建独立的Spring应用程序的框架

2.内嵌Tomcat，不需要依赖于外部Tomcat

3.简化Maven配置

4.自动配置Spring

5.绝对没有代码生成和对XML没有要求配置

6.微服务的入门级微框架，springboot是springcloud的基础

2、SpringBoot环境搭建

方案一：通过Spring官网进行项目构建，然后下载到本地，导入到IDE当中 http://start.spring.io/

方案二：通过IDE编译器创建一个SpringBoot工程

方案三：创建普通的Maven工程，然后导入SpringBoot依赖

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-parent</artifactId>

<version>2.1.4.RELEASE</version>

</parent>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-web</artifactId>

</dependency>

创建了一个控制器

/**

* @Controller

* @ResponseBody 指定该控制器中所有的方法上默认都加了@ResponseBody

@RestController

@RequestMapping("/hello")

public class HelloController {

@RequestMapping("/firstRequest")

public String firstRequest(){

System.out.println("进入到控制方法，请注意~");

return "SpringBoot First";

}

创建了一个启动类：

@SpringBootApplication //启动加载默认配置的注解

/**

* SpringBootConfiguration Spring默认配置

* EnableAutoConfiguration 启用Spring默认配置

* ComponentScan 扫描所有包下的注解

public class StartSpringBootProject {

public static void main(String[] args) {

SpringApplication.run(StartSpringBootProject.class,args);

}

问题：启动类需要注意其位置，默认只能扫描它所在包下的所有注解

启动类默认通过@ComponentScan扫描当前启动类所在包下的所有注解

如果其他的包和启动类不在一层的情况下，是默认扫描不到的，可以通过@ComponentScan("com.wdksoft")扫描指定的包

一般情况下都会将启动类放在与其他包相同目录的一层当中，但是启动类不能使用默认包Default

3、静态资源

SpringBoot一般是一各普通的MavaenJava工程，如果涉及到静态资源则需要将静态资源放在resources配置目录下，与以往操作不同

静态资源需要在resources目录下创建

static文件夹或者public文件夹，将静态资源放到static或者public当中，根据层级目录进行访问，但是不需要加static目录或者pulbic目录

利用Contrller做资源定向：

@Controller

@RequestMapping("/resources")

public class ResourcesContrller {

@RequestMapping("/getResource")

public String getResource(){

return "/html/index.html";

}

4、SpringBoot设置异常处理器

4.1 局部

/**

* 局部异常处理

* @param ex

* @return

@ExceptionHandler(RuntimeException.class)

@ResponseBody

public String exceptionHandler(Exception ex){

if(ex instanceof ArithmeticException){

return "服务器内部错误~";

}

return "发生错误，请稍后重试~";

}

4.2 全局

@ControllerAdvice //利用AOP思想增强每一个Controller

public class MyException {

/**

* 局部异常处理

* @param ex

* @return

二、SpringBoot整合JSP

1、步骤一：创建一个Maven web project

2、步骤二：引入依赖

<groupId>javax.servlet</groupId>

<artifactId>javax.servlet-api</artifactId>

</dependency>

<groupId>javax.servlet</groupId>

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-tomcat</artifactId>

</dependency>

<groupId>org.apache.tomcat.embed</groupId>

<artifactId>tomcat-embed-jasper</artifactId>

</dependency>

3、步骤三：创建配置文件，修改SpringBoot的默认配置，如Tomcat端口

第一种形式：application.properties

server.port=8081

第二种形式：application.yml 格式要求非常严格

server

port: 8081

第三种：bootstrap.properties，bootstrap.yml

bootstrap和application区别：

Spring Cloud 构建于 Spring Boot 之上，在 Spring Boot 中有两种上下文，一种是 bootstrap, 另外一种是 application, bootstrap 是应用程序的父上下文，也就是说 bootstrap 加载优先于 applicaton。

bootstrap 主要用于从额外的资源来加载配置信息，还可以在本地外部配置文件中解密属性。这两个上下文共用一个环境，它是任何Spring应用程序的外部属性的来源。bootstrap 里面的属性会优先加载，

它们默认也不能被本地相同配置覆盖。

创建SpringBoot配置文件：

application.properties

4、步骤四：创建控制器，实现请求的转发

@Controller

@RequestMapping("/jspCon")

public class JSPController {

@RequestMapping("/getJSPRequest")

public ModelAndView getJSPRequest(){

System.out.println("进入到控制方法");

ModelAndView modelAndView=new ModelAndView();

modelAndView.setViewName("get");

modelAndView.addObject("message","2020年4月2日14:46");

return modelAndView;

}

5、步骤五：启动类

@SpringBootApplication

public class StartSpringBoot {

public static void main(String[] args) {

SpringApplication.run(StartSpringBoot.class,args);

}

注意问题：启动类所启动的工程如果是父子工程的情况下，默认找父工程，但是内容写入到了子工程，这时就需要让启动类将当前子工程作为工作目录，找到

Working dirctory选择$model......

use classpath of model 选择当前工程即可

三、SpringBoot整合freemarker

1、步骤一：导入依赖

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-freemarker</artifactId>

</dependency>

2、步骤二：新建一个freemarker模板

首先在resources下创建一个templates文件夹，在该文件夹下创建一个html文件，将html后缀改为ftl即可，在模板中可以采用${xxx}进行取值

<!DOCTYPE html>

<head>

<title>FreeMarker</title>

</head>

<body>

欢迎：${name}

</body>

</html>

3、步骤三：在配置文件中添加freemarker配置

spring.freemarker.template-loader-path=classpath:/templates/

spring.freemarker.cache=false

spring.freemarker.charset=UTF-8

spring.freemarker.check-template-location=true

spring.freemarker.content-type=text/html

spring.freemarker.expose-request-attributes=false

spring.freemarker.expose-session-attributes=false

spring.freemarker.request-context-attribute=request

4、步骤四：新建一个Controller控制器，通过控制方法传递数据以及跳转到模板页面

@Controller

@RequestMapping("/free")

public class FreeMarkerController {

@RequestMapping("/freeRequest")

public String freeRequest(Model model){

System.out.println("进入到控制方法");

model.addAttribute("name","张三");

return "HelloFreeMarker";

}

页面：

<#if userInfo.userCode == 1 >

呵呵

<#else>

哈哈

</#if>

<#list userList as user>

${user.userName}

</#list>

博客：

https://www.cnblogs.com/jingwhale/p/4644566.html

https://www.cnblogs.com/xiufengchen/p/10404872.html

四、SpringBoot整合thymeleaf

概念:

动静结合：Thymeleaf 在有网络和无网络的环境下皆可运行，即它可以让美工在浏览器查看页面的静态效果，也可以让程序员在服务器查看带数据的动态页面效果。

这是由于它支持 html 原型，然后在 html 标签里增加额外的属性来达到模板+数据的展示方式。浏览器解释 html 时会忽略未定义的标签属性，

所以 thymeleaf 的模板可以静态地运行；当有数据返回到页面时，Thymeleaf 标签会动态地替换掉静态内容，使页面动态显示。

1、步骤一：导入依赖

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-thymeleaf</artifactId>

</dependency>

2、步骤二：新建一个模板

</tr>

3、步骤三：配置thymeleaf，不配置也可以

#设置thymeleaf

#springboot 官方文档建议我们关闭thymeleaf的缓存

spring.thymeleaf.cache=false

4、步骤四：新建控制方法进行转发

@RequestMapping("/thyRequest")

public String thyRequest(Model model){

System.out.println("进入到控制方法");

UserInfo userInfo1=new UserInfo("赵云",2);

UserInfo userInfo2=new UserInfo("赵耀",3);

UserInfo userInfo3=new UserInfo("赵子龙",4);

List<Object> list=new ArrayList<>();

list.add(userInfo1);

list.add(userInfo2);

list.add(userInfo3);

model.addAttribute("userList",list);

return "index";

}

博客：https://www.cnblogs.com/msi-chen/p/10974009.html

五、SpringBoot整合Mybatis

1、步骤一：SpringBoot和Mybatis整合依赖

<groupId>mysql</groupId>

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

</dependency>

<groupId>org.mybatis.spring.boot</groupId>

<artifactId>mybatis-spring-boot-starter</artifactId>

</dependency>

<groupId>com.github.pagehelper</groupId>

<artifactId>pagehelper</artifactId>

</dependency>

2、步骤二：创建Mapper层接口

@Repository

public interface UserInfoMapper {

@Select("select * from user_info")

public List<UserInfo> getAllUser();

}

3、步骤三：创建Service层

public interface UserInfoService {

public List<UserInfo> getAllUser();

}

@Service

public class UserInfoServiceImpl implements UserInfoService {

@Resource

private UserInfoMapper userInfoMapper;

@Override

public List<UserInfo> getAllUser() {

return userInfoMapper.getAllUser();

}

4、步骤四：创建Controller层

@RestController

@RequestMapping("/user")

public class UserInfoController {

@Resource

private UserInfoService userInfoService;

@RequestMapping("/getAllUser")

public Object getAllUser(){

return userInfoService.getAllUser();

}

5、步骤五：配置文件

#数据原

spring:

datasource:

driver-class-name: com.mysql.jdbc.Driver

url: jdbc:mysql://localhost:3306/springboott26

username: root

password: root

mybatis:

config-location: classpath:mybatis-config.xml

6、步骤六：启动类

@SpringBootApplication

@MapperScan("com.wdksoft.mapper")

public class StartMybaits {

public static void main(String[] args) {

SpringApplication.run(StartMybaits.class,args);

}

六、SpringBoot整合JDBCTemplate

1、步骤一：导入依赖

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-jdbc</artifactId>

</dependency>

<groupId>mysql</groupId>

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

</dependency>

2、步骤二：创建Mapper层

public interface UserInfoMapper {

public void insert(UserInfo userInfo);

public void update(UserInfo userInfo);

public void delete(Integer userId);

public UserInfo findById(Integer userId);

public List<Map<String, Object>> findAll();

}

3、步骤三：Mapper接口的实现类

@Repository

public class UserInfoMapperImpl implements UserInfoMapper{

//引入JDBCTemplate对象

@Resource

private JdbcTemplate jdbcTemplate;

@Override

public void insert(UserInfo userInfo) {

String sql="insert into user_info(user_name,user_email) values(?,?)";

jdbcTemplate.update(sql,userInfo.getUserName(),userInfo.getUserEmail());

}

@Override

public void update(UserInfo userInfo) {

String sql="update user_info set user_name=? where user_id=?";

jdbcTemplate.update(sql,userInfo.getUserName(),userInfo.getUserId());

}

@Override

public void delete(Integer userId) {

String sql="delete from user_info where user_id=?";

jdbcTemplate.update(sql,userId);

}

@Override

public UserInfo findById(Integer userId) {

String sql="select * from user_info where user_id=?";

RowMapper<UserInfo> rowMapper=new BeanPropertyRowMapper<>(UserInfo.class);

/**

* 参数一：sql

* 参数二：对应结果集的封装

* 参数三：条件

UserInfo userInfo = jdbcTemplate.queryForObject(sql, rowMapper, userId);

return userInfo;

}

@Override

public List<Map<String, Object>> findAll() {

String sql="select * from user_info";

List<Map<String, Object>> maps = jdbcTemplate.queryForList(sql);

return maps;

}

后续操作一致

七、SpringBoot整合SpringDataJPA

1、什么是SpringDataJPA

SpringDataJPA是SpringData当中实现的一个小的模块，可以利用该模块简化JPA操作，使数据访问更加方便简单

2、开发SpringDataJPA工程

步骤一：导入依赖

<groupId>mysql</groupId>

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

</dependency>

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

步骤二：配置配置文件

#数据源配置注意层级和空格

spring:

datasource:

driver-class-name: com.mysql.jdbc.Driver

url: jdbc:mysql://localhost:3306/springboott26

username: root

password: root

#配置JPA

jpa:

database: mysql

show-sql: true

hibernate:

ddl-auto: update

步骤三：创建实体

@Entity

public class UserInfo {

@Id

@GeneratedValue(strategy = GenerationType.AUTO)

private Integer userId;

@Column

private String userName;

private String userEmail;

}

步骤四：创建Mapper层

/**

* 参数一：实体类型

* 参数二：主键ID类型

* Repository可以会将接口自动注入到容器当中

public interface UserInfoMapper extends CrudRepository<UserInfo,Integer> {

}

步骤五：创建Service层接口和实现类

public interface UserInfoService {

public void insertUser(UserInfo userInfo);

public void updateUser(UserInfo userInfo);

public void deleteUser(Integer userId);

public Iterable<UserInfo> getAllUser();

public UserInfo getAllUserByID(Integer userId);

}

Impl当中重写该方法，然后调用MAPPER

@Service("userInfoService")

public class UserInfoServiceImpl implements UserInfoService {

@Resource

private UserInfoMapper userInfoMapper;

@Override

public void insertUser(UserInfo userInfo) {

userInfoMapper.save(userInfo);

}

@Override

public void updateUser(UserInfo userInfo) {

userInfoMapper.save(userInfo);

}

@Override

public void deleteUser(Integer userId) {

userInfoMapper.deleteById(userId);

}

@Override

public Iterable<UserInfo> getAllUser() {

/* List<UserInfo> list = Lists.newArrayList(userInfoMapper.findAll());*/

return userInfoMapper.findAll();

}

@Override

public UserInfo getAllUserByID(Integer userId) {

//将项目改为8版本

Optional<UserInfo> optional = userInfoMapper.findById(userId);

return optional.get();

}

步骤六：编写Controller层

@RestController

@RequestMapping("/user")

public class UserInfoController {

@Resource

private UserInfoService userInfoService;

@RequestMapping("/insert")

public String insert(){

UserInfo userInfo=new UserInfo();

userInfo.setUserName("柴英杰");

userInfo.setUserEmail("123@qq.com");

userInfoService.insertUser(userInfo);

return "success";

}

@RequestMapping("/update")

public String update(){

UserInfo userInfo=new UserInfo();

userInfo.setUserName("赵云");

userInfo.setUserEmail("234@qq.com");

userInfo.setUserId(1);

userInfoService.updateUser(userInfo);

return "success";

}

@RequestMapping("/delete")

public String delete(){

userInfoService.deleteUser(1);

return "success";

}

@RequestMapping("/getUserById")

public Object getUserById(){

return userInfoService.getAllUserByID(2);

}

@RequestMapping("/getAllUser")

public Object getAllUser(){

return userInfoService.getAllUser();

}

八、SpringBoot整合Dubbo

Dubbo是一款分布式的RPC远程调用框架，默认采用Dubbo协议，HTTP协议，Heassion协议.........

Dubbo中分为生产者角色（生产服务发布到注册中心当中）

消费者角色（从注册中心中获取发布的服务）

注册中心：以zookeeper作为注册中心

监听中心：记录

1、SpringBoot整合Dubbo生产者

步骤一：导入依赖

<artifactId>zkclient</artifactId>

</dependency>

<groupId>com.alibaba.spring.boot</groupId>

<artifactId>dubbo-spring-boot-starter</artifactId>

</dependency>

<groupId>com.wdksoft</groupId>

<artifactId>springboot_dubbo_public</artifactId>

<version>1.0-SNAPSHOT</version>

</dependency>

步骤二：创建一个接口的实现类，将该实现类发布出去

@Service(interfaceClass = DoSomeService.class) //利用Dubbo将接口发布

@Component //将当前类注入到容器

public class DoSomeServiceImpl implements DoSomeService {

@Override

public String doSome(String userName) {

System.out.println("生产者提供的DoSomeService接口的业务方法");

return "Springboot Dubbo Provider";

}

步骤三：创建启动类

@SpringBootApplication

@EnableDubboConfiguration

public class StartPro {

public static void main(String[] args) {

SpringApplication.run(StartPro.class,args);

}

步骤四：配置Dubbo

#应用提供方

spring.dubbo.application.name=springboot-dubbo-provider

#注册中心地址

spring.dubbo.registry.address=zookeeper://127.0.0.1:2181

#dubbo协议

spring.dubbo.protocol.name=dubbo

#协议暴露端口

spring.dubbo.protocol.port=20880

2、SpringBoot整合Dubbo消费者

步骤一：导入依赖

步骤二：创建一个Controller，调用Dubbo声明的接口

@RestController

public class DoSomeController {

@Reference

private DoSomeService doSomeService;

@RequestMapping("/doSome")

public String doSome(){

return doSomeService.doSome("柴英杰");

}

步骤三：配置文件

spring.dubbo.application.name=springboot-dubbo-consumer

spring.dubbo.registry.address=zookeeper://127.0.0.1:2181

server.port=8081

步骤四：启动类：

@SpringBootApplication

@EnableDubboConfiguration

public class StartCon {

public static void main(String[] args) {

SpringApplication.run(StartCon.class,args);

}

九、SpringBoot如何控制事务

1、事务控制

一般在Service层，采用@Transactional控制事务，该注解可以打在类上或者方法上，一般来说如果方法不是public会失效，同样注意数据库表的存储引擎要为InnoDB

@Override

@Transactional(isolation = Isolation.READ_COMMITTED)

public int insertUser(UserInfo userInfo) {

int count = userInfoMapper.insertUser(userInfo);

int result=5/0;

return count;

}

十、SpringBoot打包发布

1、数据库准备

步骤一：在虚拟机当中安装mysql数据库

步骤二：将当前本机的SQL脚本通过xftp工具上传到虚拟机当中

步骤三：登陆到数据库服务器

mysql -uroot -p密码

步骤四：source /usr/local/springboot/springboott26.sql

2、项目打包

导入依赖：

<groupId>org.springframework.boot</groupId>

<artifactId>spring-boot-maven-plugin</artifactId>

</plugin>

将项目双击install进行打包，在target目录下找到该包，然后上传到linux服务器当中

3、项目启动发布

依赖于jdk

切换到jar所在目录，启动工程：java -jar springboot_project.jar

设置后台启动：nohup java -jar springboot_project.jar > log.file 2>&1 &

posted @ 2020-04-02 10:47 F阿东阅读(202) 评论(0) 收藏举报

刷新页面返回顶部

F阿东

Springboot框架笔记

SpringBoot框架

一、SpringBoot概述

1、SpringBoot特性

2、SpringBoot环境搭建

3、静态资源

4、SpringBoot设置异常处理器

二、SpringBoot整合JSP

1、步骤一：创建一个Maven web project

2、步骤二：引入依赖

3、步骤三：创建配置文件，修改SpringBoot的默认配置，如Tomcat端口

4、步骤四：创建控制器，实现请求的转发

5、步骤五：启动类

三、SpringBoot整合freemarker

1、步骤一：导入依赖

2、步骤二：新建一个freemarker模板

3、步骤三：在配置文件中添加freemarker配置

4、步骤四：新建一个Controller控制器，通过控制方法传递数据以及跳转到模板页面

四、SpringBoot整合thymeleaf

1、步骤一：导入依赖

2、步骤二：新建一个模板

3、步骤三：配置thymeleaf，不配置也可以

4、步骤四：新建控制方法进行转发

五、SpringBoot整合Mybatis

1、步骤一：SpringBoot和Mybatis整合依赖

2、步骤二：创建Mapper层接口

3、步骤三：创建Service层

4、步骤四：创建Controller层

5、步骤五：配置文件

6、步骤六：启动类

六、SpringBoot整合JDBCTemplate

1、步骤一：导入依赖

2、步骤二：创建Mapper层

3、步骤三：Mapper接口的实现类

七、SpringBoot整合SpringDataJPA

1、什么是SpringDataJPA

2、开发SpringDataJPA工程

八、SpringBoot整合Dubbo

1、SpringBoot整合Dubbo生产者

2、SpringBoot整合Dubbo消费者

九、SpringBoot如何控制事务

1、事务控制

十、SpringBoot打包发布

1、数据库准备

2、项目打包

3、项目启动发布

公告