springboot框架学习理解上

最新推荐文章于 2024-06-22 18:28:36 发布

爱码～

最新推荐文章于 2024-06-22 18:28:36 发布

阅读量257

点赞数 1

分类专栏：框架文章标签： spring boot

本文链接：https://blog.csdn.net/weixin_47120348/article/details/120661303

版权

框架专栏收录该内容

24 篇文章 0 订阅

订阅专栏

从maven变成boot
1 继承只有继承了boot的父级项目才是springboot项目
2 依赖启动器
3 手动编写启动类

<?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.bjsxt.springbootnewstyle</groupId>
    <artifactId>springbootnewhaha</artifactId>
    <version>1.0-SNAPSHOT</version>
    <!--必须要继承父工程-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
    <!--一定要注入springboot的启动器 所谓的启动器就是一些jar包的集合 springboot框架将jar分类成
        不同的启动器，使用哪个启动器就代表导入了哪些jar包，springboot一共提供了44中启动器，
        spring-boot-starter-web 支持了全栈式的开发，包含了jar包有tomcat,springmvc等，
    -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
</project>
========================

@Controller
public class Mvc {
    @RequestMapping("/hello")
    @ResponseBody
    public Map<String,Object> show(){
        Map<String, Object> map = new HashMap<>();
        map.put("张三","18");
        return map;
    }
}
================================
@SpringBootApplication  //启动类的第一点加注解
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args); 
        //在main方法中调用springapplication类中的run方法启动boot框架，参数是启动类的class和main方法中的参数
    }
}
================================
   <!--可以指定jdk的版本号-->
    <properties>
        <java.version>1.8</java.version>
    </properties>
    ====================================
     <!--这是一个打包插件 如果项目没有这个插件，那么在打包时候是不会把boot中依赖的jar打包到项目中的-->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

注意关于编写启动器的位置
启动器存放的位置：启动器可以controller类位于同一个包下，或者启动器高于controller。但不能把启动器放到平级的其他包中，或是子包。防止启动器扫描不到其他类，
启动类
springboot框架内嵌了tomcat,所以不需要用容器来启动项目，而是用启动类来启动框架了，
启动类的作用是启动boot框架，是基于main方法运行的，
启动类在启动的时候会做注解扫描包含@controller,@Service @Repository ,扫描位置为同包或是子包下的注解，
启动器starter
boot框架将功能场景进行了分类，做成了不同的启动器，项目中引入了启动器后相关的依赖会导入进来，在jar包管理上非常方便，
springboot提供了44中启动器：
配置文件
springboot框架可以设置全局配置文件，名字为application的全局文件，支持两种格式properteis和yaml格式；
配置文件存放的位置
1当前项目的根目录下；
2当前目录下的config目录中；
3项目中的resources其实就是classpath的根路径；
4 项目中的resources中的config目录中；
注意优先加载properties文件
配置文件中的占位符
1 "${}"是占位符，可以获取方法中的值 random.int
2 可以获取配置文件中的键的值，根据键获取值；
springboot的核心注解
1 @springbootApplication
是标识为启动类，这个注解是相当于多个注解组成而成，@configuration + @EnableAutoConfiguration+ComponentScan 的组合，
2 @SpringbootConfiguration
是@configuration注解的子注解，功能是一样的，标注这个类是配置类，会自动扫描并实例化运行里面的方法，注意 SpringbootConfiguration是boot框架的注解，@configuration是spring中的注解，
3 @configuration
这个注解是代表注解类，通过bean对象的操作代替spring中的xml配置文件，
4 @EnableAutoconfiguration
这个注解是springboot中的自动装配注解，能够根据你添加的jar依赖自动配置你的spring应用，是@AutoconfigurationPackage和@import注解的组成，
5 @AutoconfigurationPackage
这个注解会自动扫描包下所有加了注解的类实例化出bean对象，（@controlle,@service,@configuration）
6 @Import
直接导入普通的类，导入实现了ImportSelector接口的类，
7 @ComponentScan
组件扫描，自动发现和装配bean对象，
8 @ConfigurationPropertiesScan
将扫描@configurationProperties注解类自动装载bean对象，
Springboot项目中常用的注解
1 @RestController
是一个组合注解 @Controller+@ResponsBody，该类下的方法return返回的就是字符串，无法返回jsp，html,无法配置视图解析器，
@Controller注解是代表是一个接口控制类，该类下的所有方法return可以是jsp，html,object,可以和视图解析器配合使用，
@ResponseBody 作用是该类下所有的api接口返回的数据都是以json字符串的形式来返回，如果返回的String,则仍是String,
2 @RequestMapping()
该注解是spring mvc中的注解，是用来处理请求地址映射的注解，属性有：
value:指定请求的地址路径
path:指定请求的地址路径
method:指定请求的方法类型；get|post|put|delete
params:必须包含某些参数；

@Controller
public class Mvc {
    @RequestMapping(path ="/hello",method = RequestMethod.GET)
    @ResponseBody
    public Map<String,Object> show(){
        Map<String, Object> map = new HashMap<>();
        map.put("张三","18");
        return map;
    }
    @RequestMapping(value ="/java",method = RequestMethod.GET,params = "name=\"李四\"")
    @ResponseBody
    public Map<String,Object> showJava(){
        Map<String, Object> map = new HashMap<>();
        map.put("李四","28");
        return map;
    }
}
请求路径：
http://localhost:8080/java?name=“李四”
http://localhost:8080/hello

3 @GetMapping
等于@RequestMapping(method=RequestMethod.GET);

springboot整合Servlet
方式一通过注解来实现Servlet组件注册


/**Springboot整合Servlet技术方式一
 * 创建一个servlet之后要在xml中配置servelt 场景如下：
 * <servlet>
 *     <servlet-name>FirstServlet</servlet-name>
 *     <servlet-class>com.bjsxt.servlet.FirstServlet</servlet-class>
 * </servlet>
 * <servlet-mapping>
 *     <servlet-name>FirstServlet</servlet-name>
 *     <url-pattern>/first</url-pattern>
 * </servlet-mapping>
 *  以上就是以前的方式来配置servelt,但是使用boot之后直接一个注解就搞定了
 *  下面就是通过注解来实现servlet组件注册
 * */
@WebServlet(name = "FirstServlet",urlPatterns = "/first")
public class FirstServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        System.out.println("webServlet启动了");
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}
=====================================
@SpringBootApplication
@ServletComponentScan //在启动时会扫描@webServlet注解并实例化 Component组件
public class App {
    public static void main(String[] args) {
        SpringApplication.run(App.class,args);
    }
}

方式二通过方法来实例化Servlet组件

package com.bjsxt;
@SpringBootApplication
//@ServletComponentScan //在启动时会扫描@webServlet注解并实例化 Component组件
public class Appa {
    public static void main(String[] args) {
        SpringApplication.run(com.bjsxt.App.class,args);
    }
    /** 用方法来实例化出Servlet组件 
     * 方法名字自定义，返回值是ServletRegistrationBean
     *  记得给方法加上@bean就行
     * */
    @Bean
    public ServletRegistrationBean getServlet(){
        //第一步先new出Servlet对象
        FirstServlet firstServlet = new FirstServlet();
        //创建一个ServletRegistrationBean对象 参数是Servlet对象
        ServletRegistrationBean servletBean = new ServletRegistrationBean(firstServlet);
        //添加一个url路径
        servletBean.addUrlMappings("/firstServlet");
        return servletBean;
    }
}

Springboot整合filter
方式一，使用注解来注册filter

package com.bjsxt.filter;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import java.io.IOException;
import java.util.logging.LogRecord;

/** Springboot整合Filter方式一过滤器
 * 首先说明过滤器是Servlet中的一个组件，不是javaEE平台技术，
 * 作用是：从客户端向服务器端发送请求进行过滤，或是对服务器返回响应进行处理，
 * 创建类继承Filter接口实现三个抽象方法，
 * init():初始化方法，在实例化后调用完成初始化动作，
 * doFilter():拦截请求或是处理响应方法，实现预处理，
 * destroy():销毁filter之前调用，一般用于资源释放，
 *  <filter>
 *      <filter-name>FirstFilter</filter-name>
 *      <filter-class>com.bjsxt.filter.FirstFilter</filter-class>
 *  </filter>
 *  <filter-mapping>
 *      <filter-name>FirstFilter</filter-name>
 *      <url-pattern>/filter</url-pattern>
 *  </filter-mapping>
 *
 *
 * */
/*@WebFilter(filterName = "FirstFilter",urlPatterns = {"*.do","*.jsp"})*/
@WebFilter(filterName = "FirstFilter",urlPatterns = "/filter")
public class FirstFilter implements Filter {


    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("进入Filter");
        filterChain.doFilter(servletRequest,servletResponse);
        System.out.println("离开Filter");

    }

    @Override
    public void destroy() {

    }
}
====================================

@SpringBootApplication
@ServletComponentScan //在启动时会扫描@webFilter注解并实例化 Component组件
public class Appa {
    public static void main(String[] args) {
        SpringApplication.run(com.bjsxt.Appa.class,args);
    }
}

Springboot配置listener
Servlet中的监听器：用来监听web应用中某些对象的创建，销毁，增删改等动作触发监听器，
监听器的分类：
1ServletContext对象监听器和属性监听器实现ServletContextListener接口，
2 HttpSession对象生命周期监听器和属性监听器
3 ServletRequest对象生命周期监听器和属性操作监听器

/** springboot整合listener
 *  方式一 通过注解扫描完成listener组件注册，
 *  <listener>
 *      <listener-class>com.bjsxt.listener.Listenerdemo</listener-class>
 *  </listener>
 *  现在只需要添加一个注解就可以了
 *  */
@WebListener//配置监听器
public class Listenerdemo implements ServletContextListener {

    //ServletContext对象创建后会触发该监听器
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("listener开始工作了？？？");
    }
    //ServletContext对象在销毁之后会触发该监听器
    @Override
    public void contextDestroyed(ServletContextEvent sce) {

    }
}
==============================
@SpringBootApplication
@ServletComponentScan //在启动时会扫描@WebListener注解并实例化 Component组件
public class Appa {
    public static void main(String[] args) {
        SpringApplication.run(com.bjsxt.Appa.class,args);
    }

}

Springboot访问静态资源
访问静态的位置有
1 Springboot从classpath/static目录下

2 从ServletContext根目录下
在src/main/webapp 创建一个webapp目录，这个根目录作为存放静态资源的位置，其实boot框架也是从tomcat中的webapp目录下找资源，
在这里插入图片描述

springboot上传文件

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>实现文件上传</title>
</head>
<body>
    <!--表单上传文件方法必须是post  enctype编码方式 是设置提交数据的格式
     multipart/form-data是代表上传二进制文件-->
    <form action="/fileuploadController" method="post" enctype="multipart/form-data">
        <input type="file" name="file"/>
        <input type="submit" value="ok"/>
    </form>
</body>
</html>

package com.bjsxt.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.annotation.MultipartConfig;
import java.io.File;

/** 实现文件上传*/
@Controller
public class FileUploadController {
    //文件上传
    @PostMapping("/fileuploadController")
    @ResponseBody
    //这个参数名字必须和form表单的名字一样
    public String fileUpload(MultipartFile file) throws Exception{
        //获取原始文件的名字
        System.out.println(file.getOriginalFilename());
        //将上传的文件转移到指定位置
        file.transferTo(new File("E:/"+file.getOriginalFilename()));
        return "上传成功！";
    }
}
============================
#配置单个上传文件的大小限制
spring.servlet.multipart.max-file-size=3MB
#配置一次请求上传多个文件的总容量大小限制
spring.servlet.multipart.max-request-size=20MB
配置文件application.properties设置

Springboot整合Freemarker
Freemarker是一个视图层技术：称为是模板视图，他运行在客户端来实现数据渲染，效率高；
jsp视图技术：完全是在tomcat服务器上运行，先把jsp运行变成servlet,最后在输出到页面上，

//第一步导入依赖
<!--freemarker启动器依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
==================================
//第二步编写controller
@Controller
public class Srpingbootfreemarker {
    /**
     *  */
    @RequestMapping("/showinfo")
    public String showinfo(Model model){
        ArrayList<Object> list = new ArrayList<>();
        list.add(new User("张三","haha"));
        list.add(new User("马六","hhaha"));
        model.addAttribute("list",list);
        return "index";
    }

}
==============================
//第三步编写ftl页面 
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <table border="1" align="center" width="50%">
        <tr>
            <th>Name</th>
            <th>Sex</th>
        </tr>
        <#list list as user>
        <tr>
            <th>${user.name}</th>
            <th>${user.age}</th>
        </tr>
        </#list>
    </table>
</body>
</html>
===========================
配置视图器后缀 实体类省略
#配置后缀名
spring.freemarker.suffix=.ftl

Springboot整合Thymeleaf
作用将html在浏览器中正确显示出来，能够处理有html,xml,js,css; 他其实是一个模板引擎，可以为模板进行数据渲染，模板一般是HTML，
thymeleaf是原生的，不依赖于标签库，能够在html页面中进行编辑和渲染，
Springboot整合jdbc

//第一步添加依赖
<!--添加JDBC启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--添加数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
         <!--添加数据库连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.4</version>
        </dependency>
===========================
//第二步配置连接数据库驱动的信息 创建jdbc.properties文件来存放连接数据库信息
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8&userSSL=false
jdbc.username=root
jdbc.password=*******
=============================
//第三步实例化处数据库连接池对象 编写一个配置类 或是用springboot配置文件来存放连接数据库信息
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8&userSSL=false
spring.datasource.username=root
spring.datasource.password=123456
#配置连接数据库连接池类型
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
===========================

注意配置数据库连接信息的方式有多种最简单的就是直接在appliction.properties中配置

#配置单个上传文件的大小限制
spring.servlet.multipart.max-file-size=3MB
#配置一次请求上传多个文件的总容量大小限制
spring.servlet.multipart.max-request-size=20MB
#配置后缀名
spring.freemarker.suffix=.html
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/ssm?useUnicode=true&characterEncoding=utf-8&userSSL=false
 # useUnicode=true&characterEncoding=utf-8&userSSL=false
spring.datasource.username=root
spring.datasource.password=123456
#配置连接数据库连接池类型
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
========================
代码第一步编写一个跳转页面的controller
package com.bjsxt.controller;

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

/** 这个是一个页面跳转的controller
 * 简单的说明一下restful风格的url
 * 主要作用是规范定义获取资源的url;实际就是将参数和url拼接在一起了，使url看起来比较简单
 * 传统风格：http://localhost:8080/index.jsp?username='张三'&userage=18
 * restful风格: http://localhost:8080/index.jsp/张三/18 这样就是参数和url拼接在一起了
 * {}是占位符；用于绑定url中的参数信息
 * @pathvaribale注解作用是：将url中的占位符参数绑定到处理方法的入参中
 * 如果方法中的参数和占位符名字不一样，就要在注解中添加value中来进行映射
 * */
@Controller
public class PageController {
    @RequestMapping("/{page}")
    public String showPage1(@PathVariable String page){
        System.out.println("我执行了");
        return page;
    }
    @RequestMapping("/{page}/{userid}")
    public String showPage2(@PathVariable(value = "page") String p,@PathVariable int userid){
        return p;
    }
}
===========================
编写一个页面来
<!DOCTYPE html>
<html lang="en" xmlns:th="http://www.w3.org/1999/xhtml">
<link rel="shortcut icon" href="../resources/favicon.ico" th:href="@{/static/favicon.ico}"/>
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="http://localhost:8080/adduserinfo" method="post">
        主键: <input type="text" name="userid"><br/>
        姓名：<input type="text" name="username"><br/>
        密码：<input type="password" name="userpwd"><br/>
             <input type="submit" value="ok"/><br/>
    </form>
</body>
</html>
==========================
编写一个接收信息的controller
package com.bjsxt.controller;

import com.bjsxt.pojo.Users;
import com.bjsxt.servlet.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class UserController {
    //将业务层注入
    @Autowired
    private UserService userService;

    @RequestMapping("/adduserinfo")
    public String adduserinfo(Users users){
        System.out.println("开始添加数据了");
        try {
            System.out.println(users.toString());
            this.userService.addUser(users);
        } catch (Exception e) {
            return "error";
        }
        return "ok";
    }
}
=============
编写服务类
package com.bjsxt.servlet.imp;

import com.bjsxt.dao.UserDao;
import com.bjsxt.pojo.Users;
import com.bjsxt.servlet.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

//服务层
@Service
public class UserServiceImpl implements UserService {
    //将持久层对象注入到属性中
    @Autowired
    private UserDao userDao;
    //添加用户 dml操作要考虑事务
    @Override
    @Transactional
    public void addUser(Users users) {
        this.userDao.insertUsers(users);
    }
}
==============================
编写dao层
package com.bjsxt.dao.impl;

import com.bjsxt.dao.UserDao;
import com.bjsxt.pojo.Users;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.support.rowset.SqlRowSet;
import org.springframework.stereotype.Repository;

import java.util.List;
import java.util.Map;
import java.util.Set;

@Repository //持久层
public class UserDaoImpl implements UserDao {
    //使用jdbc来操作数据库 注入jdbc对象
    @Autowired
    private JdbcTemplate jdbcTemplate;
    //添加用户信息
    @Override
    public void insertUsers(Users users) {
        System.out.println(users.toString());
        String sql_insert = "insert into users(userid,username,userpwd) values(?,?,?)";
        //String sql_query = "select * from users";
        //注意update可以执行所有的DML操作insert delete update
        this.jdbcTemplate.update(sql_insert,users.getUserid(),users.getUsername(),users.getUserpwd());
        


    }
}

springboot整合mybatis
1创建项目
1添加依赖

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.zixue</groupId>
    <artifactId>springbootmybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springbootmybatis</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <!--jdbc启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--springweb启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--数据库驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!--测试模块-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <!--mybatis依赖 和boot整合依赖注意啊 不是boot官方的-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>
        <!--数据源-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.4</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>
        <!--视图转化器-->
        <!--freemarker启动器依赖视图技术 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!--打包插件-->
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3配置文件


spring:
    datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/mybatisplus?useUnicode=true&characterEncoding=utf-8&userSSL=false
        password: 123456
        username: root
        type: com.alibaba.druid.pool.DruidDataSource
    freemarker:
        suffix: .html

4 查看数据库是否连接成功

package com.zixue.springbootmybatis;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.sql.DataSource;
import java.sql.SQLException;

@SpringBootTest
class SpringbootmybatisApplicationTests {
    @Autowired
    DataSource dataSource;

    @Test
    void contextLoads() throws SQLException {
        System.out.println(dataSource.getClass());
        System.out.println(dataSource.getConnection());
    }

}

在这里插入图片描述

创建mapper层
写接口这里需要注解的含义

package com.zixue.springbootmybatis.mapper;

import com.zixue.springbootmybatis.pojo.Employee;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

/** 表示是mybatis的持久层类
 * @mapper这个注解是mybatis框架中的注解， 代表是一个接口
 * @Repository是spring中的一个持久层注解
 * */
@Mapper
@Repository
public interface EmployeeMapper {
    //查询全部信息
    List<Employee> queryEmplist();
    //查询一信息
    Employee queryempbyid(int id);
    //添加一条信息
    int addemp(Employee employee);
    //更新一条信息
    int updateemp(Employee employee);
    //删除一条信息 注解测试示例哈
   int deleteemp(int id);
    @Select("select * from employee")
    List<Employee> allinfo();

}

写mapper映射配置文件写在resources/mybatis/mapper/EmployeeMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zixue.springbootmybatis.mapper.EmployeeMapper"><!--要记得映射mapper接口啊-->
  <!--id就是对应mapper接口的方法名字 resultType是映射结果到实体类中-->
  <select id="queryEmplist" resultType="Employee">
    select * from employee
  </select>
  <select id="queryempbyid" resultType="Employee">
      select * from employee where id=#{id}
  </select>
  <select id="addemp" resultType="int">
      insert into employee(id,name,email,gender,age) values(#{id},#{name},#{email},#{gender},#{age})
  </select>
  <select id="updateemp" resultType="int">
      update employee set name =#{name},email= #{email},gender=#{gender},age=#{age} where id=#{id}
  </select>
  <select id="deleteemp" resultType="int">
      delete from employee where id=#{id}
  </select>
</mapper>

注意在配置文件中要配置mybatis框架


spring:
    datasource:
        driver-class-name: com.mysql.jdbc.Driver
        url: jdbc:mysql://localhost:3306/mybatisplus?useUnicode=true&characterEncoding=utf-8&userSSL=false
        password: 123456
        username: root
        type: com.alibaba.druid.pool.DruidDataSource
    freemarker:
        suffix: .html
#整合mybatis框架配置 设置类别名啊
mybatis:
    type-aliases-package: com.zixue.springbootmybatis.pojo
    #配置扫描配置文件啊
    mapper-locations: classpath:mybatis/mapper/*.xml

最后下控制类

package com.zixue.springbootmybatis.controller;

import com.zixue.springbootmybatis.mapper.EmployeeMapper;
import com.zixue.springbootmybatis.pojo.Employee;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
public class EmployeeController {
    @Autowired
    private EmployeeMapper employeeMapper;

    @RequestMapping("/selectall")
    public List<Employee> selectall(){
        List<Employee> employees = employeeMapper.queryEmplist();
        employees.stream().forEach(System.out::print);
        return employees;
    }

    @RequestMapping("/selectbyid")
    public Employee selectbyid(int id){
        Employee queryempbyid = employeeMapper.queryempbyid(id);
        return queryempbyid;
    }

    @RequestMapping("/insertdata")
    public int insertdata(Employee employee){
        System.out.println("添加开始");
        int addemp = employeeMapper.addemp(employee);
        return addemp;
    }

    @RequestMapping("/updateinfo")
    public int updateinfo(Employee employee){
        int updateemp = employeeMapper.updateemp(employee);
        return updateemp;
    }

    @RequestMapping("/deleteinfo")
    public int deleteinfo(int id){
        int deleteemp = employeeMapper.deleteemp(id);
        return deleteemp;
    }

}

springboot整合swagger
前后端分离才会使用的工具用来做api文档还可以进行测试啊

1导入依赖

 <!--swagger2 依赖和ui界面 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>

2配置swagger 创建一个配置类

package com.zixue.springbootmybatis.config;

import com.zixue.springbootmybatis.controller.EmployeeController;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

import java.lang.annotation.Annotation;

/** 配置swagger组件
 * 配置类
 * @enableSwagger2开启
 * 访问页面是/swagger-ui.html
 * */
@Configuration
@EnableSwagger2
public class SwaggerConfig {
    /** 配置swagger-ui页面内容需要Docket对象类
     * 下面配置wagger基本信息简绍
     * */
    @Bean
    public Docket docket(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(new ApiInfo(
                "大明","好好学习","1.0","","","",""
        ))//配置基本信息
                .groupName("1组")//配置api分组
        .select()
        .apis(RequestHandlerSelectors.basePackage("com.zixue.springbootmybatis.controller"))//扫描包下的接口
         .build();
    }
    //设置多个分组api方便实现模块化
    @Bean
    public Docket docket1(){
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(new ApiInfo(
                        "大明2号","不好好学习","1.0","","","",""
                ))//配置基本信息
                .groupName("2组")//配置api分组
                .select()
                .apis(RequestHandlerSelectors.basePackage("com.zixue.springbootmybatis.controller"))//扫描包下的接口
                .build();
    }
}

3 对实体类添加注解

package com.zixue.springbootmybatis.pojo;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
@ApiModel("这个实体类是存放信息的")//swagger扫描实体类加上注解
public class Employee {
    @ApiModelProperty("这个属性是主键")
    private int id;
    @ApiModelProperty("姓名")
    private String name;
    private String email;
    private String gender;
    private int age;


}

4扫描控制类啊

package com.zixue.springbootmybatis.controller;

import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
@RequestMapping("/page")
public class PageController {
    @ApiOperation("跳转页面的控制类")
    @RequestMapping("/{page}")
    public String showpage(@PathVariable @ApiParam("页面名字") String page){
        System.out.println("页面跳转");
        return page;
    }

}

进行测试啊
在这里插入图片描述

springbootc处理异常的跳转页面的方法
1 通过@ExceptionHandler注解处理异常

添加出现异常的控制器和能够处理异常的控制器方法
 //进行处理nullpointer异常的控制类，
    //这个注解的作用就是根据触发的异常跳转到相对应的视图，
    @ExceptionHandler(value = {java.lang.NullPointerException.class})
    public ModelAndView nullException(Exception e){
        //创建一个页面视图
        ModelAndView mav = new ModelAndView();
        //视图存放异常信息
        mav.addObject("err",e.toString());
        //设置异常处理页面视图名称
        mav.setViewName("error");

        return mav;

    }
    //会报错的方法
    @RequestMapping("nullexception")
    public String nullexcetption(){
        Employee querynull = employeeMapper.querynull();
        int id = querynull.getId();//会报错
        return querynull.toString();
    }
    -----------------
    设置跳转的页面在templates目录下
```HTML
<!DOCTYPE html>
<html lang="zh-CN" xmlns:th="http://www.thymeleaf.org">
<head>
    <meta charset="UTF-8">
    <title>错误页面</title>
</head>
<body>
        报错了
        <span th:text="hello"></span>
        <span th:text="${err}"></span>
</body>
</html>


```java
配置模板视图解析器
spring:
    thymeleaf:
        cache: false
        mode: HTML5
        suffix: .html

爱码～

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
springboot框架学习理解上

从maven变成boot1 继承只有继承了boot的父级项目才是springboot项目2 依赖启动器3 手动编写启动类<?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.
复制链接

扫一扫

专栏目录