SpringBoot深入简出之篇六

最新推荐文章于 2023-03-01 14:38:00 发布

朝油

最新推荐文章于 2023-03-01 14:38:00 发布

阅读量262

点赞数

分类专栏： SpringBoot

本文链接：https://blog.csdn.net/qq_41910568/article/details/91129462

版权

SpringBoot 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

SpringBoot深入简出之篇六

Docker
1）、简介
Docker是一个开源的应用容器引擎（类似于JVM），基于Go语言并遵从Apache2.0协议开源。Docker可以让开发者把打包好的应用以及依赖到一个轻量级，可移植的容器中，然后发布到任何流行的Linux机器上，也可以实现虚拟化。容器是完全适应沙箱机制，互相之间不会有任何接口关联都是独立的，更重要的是容器性能开销极低。
Docker 支持将软件编译成一个镜像；然后在镜像中对好各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像；
镜像：比如说我们的windows系统是微软公司提前把一些常用的应用软件安装好，我们直接安装这个系统就可以获取到系统中的软件了。
运行中的这个镜像称为容器，容器启动时非常快速的。
Docker 核心概念
docker 主机（host）：安装了Docker程序的机器（Docker直接安装在操作系统之上）；
docker 客户端（client）：连接docker 主机进行操作；
docker 仓库（Registry）：用来保存各种打包好的软件镜像
docker 镜像（Images）：软件打包好的镜像；放置docker 仓库中；
docker 容器（Container）：镜像启动后的实例被称为一个容器；容器是独立运行的一个或一组应用

使用步骤：
1）、安装Docker
2）、去Docker 仓库找到这个软件对应的镜像
3）、使用Docker 运行这个镜像，这个镜像就会生成一个Docker容器；
4）、对容器的启动停止就是对这个运行软件的启动与停止
安装 Docker
1）、VMWare、VirtualBox（安装）；
2）、导入虚拟机文件centos7-atguigu.ova 【提取码：bq0z】
3）、双击启动Linux虚拟机；使用 root/123456 账号密码登录
4）、使用客户端连接Linux服务器进行命令操作；
5）、设置虚拟机网络；
桥接网络=选好网卡==接入网线；
6）、设置好网络后使用命令【~# service network reset】重启虚拟机的网络
7）、查看Linux的ip地址【~# ip addr】

8）、在Linux系统上去下载docker（只有Linux在3.0以上的版本才可以安装docker），中间会有一步需要输入Y的授权同意下载的操作【# yum install docker】

9）、查看并下载mysql【# docker search mysql】

docker的常规操作

操作	命令	说明
下载	yum install -y docker:19.03.2	-y(下载的时候会出现一些选择都选yes)， docker:19.03.2(版本号)
启动	systemctl start docker	手动启动docker镜像
自动启动	systemctl enable docker.service	宿主机开启即自动启动docker
检索	docker search 关键字（mysql、Redis）	我们经常会去docker hub 上检索镜像的详细信息，如镜像的tag（版本号）
拉取	docker pull 镜像名：tag	:tag（可选），tag表示标签，多为软件的版本号，默认是latest（最新版）
列表	docker images	查看本地的镜像
删除	docker rmi image-id	删除指定的本地镜像

搜索docker镜像

容器操作(在Linux系统上安装软件，如：Tomcat）
1）、软件镜像（QQ安装程序）—运行镜像—产生一个容器（正在运行当中的软件，如QQ）

操作	命令	说明
手动运行	docker run --name container-name -d image-name（docker run --name myredis -d redis）	–name：自定义容器名、-d：后台运行、image-name：指定镜像模板
自动运行	docker run --restart=always --name container-name -d image-name（docker run --name myredis -d redis）	–restart=always(开启自动运行功能)
列表	docker ps（查看运行中的容器）	加上-a；可以查看所有的容器
停止	docker stop container-name/container-id	停止当前运行中的容器
启动	docker start container-name/container-id	启动容器
删除	docker rm docker-id	删除指定的容器
端口映射	-p 8080:8090(docker run -d -p 8080:8090 --name myredis docker.io/redis)	-p：主机端口（映射）内部的端口号
容器日志	docker logs container-name/container-id
更多命令	https://docs.docker.com/engine/reference/commandine/docker/

   步骤：
   1、搜索镜像
   	docker search tomcat
   2、下载镜像
   	docker pull tomcat
   3、根据镜像启动容器
   	docker run --name mytomcat -d tomcat
   4、查看运行中容器
   	docker ps
   5、停止运行中的容器
   	docker stop mytomcat
   6、查看所有的容器
   	docker ps -a
   7、启动容器
   	docker start mytomcat
   8、删除容器
   	docker rm mytomcat
   9、启动一个做了端口映射的Tomcat
   	docker run -d -p 8090:8080 --name mytomcat docker.io/tomcat
   	-d：后台运行
   	-p：将主机的端口映射到容器的一个端口    主机端口：容器内部端口
   10、为了确保外部客户能对虚拟机端口访问成功，把内部虚拟机防火墙关闭了
   	service firewalld status：查看防火墙命令
   	service firewalld stop：关闭防火墙命令
   11、查看容器的日志
   	docker logs mytomcat 
   12、更多命令参看
   	https://docs.docker.com/engine/reference/commandine/docker/

以安装Tomcat容器环境为例：
①、docker search tomcat
②、docker pull tomcat
③、docker run -d -p 8290:8080 --name mytomcat docker.io/tomcat
在这里插入图片描述

启动mysql
在这里插入图片描述

SpringBoot与数据访问
1）、创建一个项目导入相关依赖

<dependencies>
     <!-- jdbc 数据源依赖场景 -->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
     </dependency>

     <!-- web应用依赖场景 -->
     <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
     </dependency>

     <!-- mysql依赖场景 -->
     <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>
 </dependencies>

2）、配置数据库连接

spring:
  datasource: #配置数据源信息
    data-username: root #数据库用户名
    data-password: 123456 #数据库登录密码
    url: jdbc:mysql://192.168.1.103:3306/jdbc #数据库连接路径（Linux系统中docker下的mysql）
    driver-class-name: com.mysql.jdbc.Driver #数据库驱动

效果：
默认使用org.apache.tomcat.jdbc.pool.DataSource 作为数据源；
数据源的相关配置都在DataSourceProperties 这个配置类下
自动配置原理：（org.springframework.boot.autoconfigure.jdbc 这个路径下都是有关操作jdbc）
①、参考DataSourceConfiguration 配置类，根据配置创建数据源，默认使用Tomcat连接池；可以使用spring.datasource.type 指定自定义的数据源类型
②、SpringBoot默认可以支持

	1、org.apache.tomcat.jdbc.pool.DataSource
	2、HikariDataSource
	3、BasicDataSource
	4、dbcp2
	5、DataSource //自定义的数据源

3）、自定义数据源类型

@Configuration
	@ConditionalOnMissingBean(DataSource.class)
	@ConditionalOnProperty(name = "spring.datasource.type")
	static class Generic {

		@Bean
		public DataSource dataSource(DataSourceProperties properties) {
			//使用DataSourceProperties 创建数据源，利用反射创建响应type的数据源，并且绑定相关属性
			return properties.initializeDataSourceBuilder().build();
		}
	}

4）、DataSourceInitializer：ApplicationListener；（自动配置数据源之后的初始化工作）
作用：
①、runSchemaScripts();//获取得到用户的数据表文件之后运行建表（**.sql）
private void runSchemaScripts() { List<Resource> scripts = getScripts("spring.datasource.schema", this.properties.getSchema(), "schema"); if (!scripts.isEmpty()) { String username = this.properties.getSchemaUsername(); String password = this.properties.getSchemaPassword(); runScripts(scripts, username, password); try { this.applicationContext .publishEvent(new DataSourceInitializedEvent(this.dataSource)); // The listener might not be registered yet, so don't rely on it. if (!this.initialized) { runDataScripts();//运行（*.sql文件）创建数据表 this.initialized = true; } } catch (IllegalStateException ex) { logger.warn("Could not send event to complete DataSource initialization (" + ex.getMessage() + ")"); } } }
②、runDataScripts();//运行（*.sql文件）创建数据表

```
private void runDataScripts() {//执行建表工作
		List<Resource> scripts = getScripts("spring.datasource.data",
				this.properties.getData(), "data");
		String username = this.properties.getDataUsername();
		String password = this.properties.getDataPassword();
		runScripts(scripts, username, password);
	}

	private List<Resource> getScripts(String propertyName, List<String> resources,
			String fallback) {//获取当前项目的（*.sql）文件
		if (resources != null) {
			return getResources(propertyName, resources, true);
		}
		String platform = this.properties.getPlatform();
		List<String> fallbackResources = new ArrayList<String>();
		fallbackResources.add("classpath*:" + fallback + "-" + platform + ".sql");
		fallbackResources.add("classpath*:" + fallback + ".sql");
		return getResources(propertyName, fallbackResources, false);
	}
```

默认只需将sql文件命名为

schema-*.sql、data-*.sql
默认：schema.sql、schema-all.sql；

自定义：（在数据源配置下）
	schema:
	      - classpath:department.sql
	     指定位置

5）、操作数据库：自动配置JdbcTemplate（jdbc模板类）

@Controller
public class Test01 {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @GetMapping("/hello")
    @ResponseBody
    public Map<String, Object> find(){
    	//查询department 这个数据表下的所有数据（先加入数据）
        List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from department");
        return list.get(0);
    }
}

6)、整合Druid 数据源

@Configuration
public class DruidUtils {

    @ConfigurationProperties("spring.dataSource")
    @Bean
    public DataSource druid(){
        return new DruidDataSource();//把自定义的一些druid 数据源配置参数同步到系统配置中
    }

    //配置Druid的监控
    //1、配置一个管理后台的Servlet
    @Bean
    public ServletRegistrationBean statViewServlet(){
        ServletRegistrationBean bean = new ServletRegistrationBean(new StatViewServlet(), "/druid/*");
        /*可配置参数
        public static final String SESSION_USER_KEY    = "druid-user";//设置数据源的用户
        public static final String PARAM_NAME_USERNAME = "loginUsername";
        public static final String PARAM_NAME_PASSWORD = "loginPassword";
        public static final String PARAM_NAME_ALLOW    = "allow";
        public static final String PARAM_NAME_DENY     = "deny";
        public static final String PARAM_REMOTE_ADDR   = "remoteAddress";
        */
        Map<String, String> map = new HashMap<>();
        map.put("loginUsername", "chaoyou");
        map.put("loginPassword", "123456");
        map.put("allow", "");//默认即为全部可访问
        map.put("deny", "");//拒绝访问
        map.put("remoteAddress", "");
        bean.setInitParameters(map);
        return bean;
    }

    @Bean
    public FilterRegistrationBean webStatFilter(){
        FilterRegistrationBean bean = new FilterRegistrationBean();
        bean.setFilter(new WebStatFilter());

        /*可配置参数
        public final static String PARAM_NAME_PROFILE_ENABLE         = "profileEnable";
        public final static String PARAM_NAME_SESSION_STAT_ENABLE    = "sessionStatEnable";
        public final static String PARAM_NAME_SESSION_STAT_MAX_COUNT = "sessionStatMaxCount";
        public static final String PARAM_NAME_EXCLUSIONS             = "exclusions";
        public static final String PARAM_NAME_PRINCIPAL_SESSION_NAME = "principalSessionName";
        public static final String PARAM_NAME_PRINCIPAL_COOKIE_NAME  = "principalCookieName";
        public static final String PARAM_NAME_REAL_IP_HEADER         = "realIpHeader";
        */

        Map<String, String> map = new HashMap<>();
        map.put("exclusions", "*.js,*.css,/drui/*");
        bean.setInitParameters(map);
        return bean;
    }
}

7）、整合mybatis

<!-- 导入mybatis 依赖场景 -->
<dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>1.3.1</version>
 </dependency>

在这里插入图片描述
使用注解版的mybatis操作

##配置数据源信息
spring:
  datasource:
    username: root
    password: 123456
    url: jdbc:mysql://192.168.1.102:3306/jdbc
    driver-class-name: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    ##数据源的其他配置信息
    initialSize: 5
    minIdle: 5
    maxActive: 20
    maxWait: 60000
    timeBetweenEvictionRunsMillis: 60000
    minEvictableIdleTimeMillis: 300000
    validationQuery: SELECT 1 FROM DUAL
    testWhileIdle: true
    testOnBorrow: false
    testOnReturn: false
    poolPreparedStatements: true
    #   配置监控统计拦截的filters，去掉后监控界面sql无法统计，'wall'用于防火墙
    filters: stat,wall,log4j
    maxPoolPreparedStatementPerConnectionSize: 20
    useGlobalDataSourceStat: true
    connectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=500
#    schema:
#      - classpath:Person.sql

########################################
##修改端口号
server:
  port: 8200

设置模型层JavaBean

public class Department {
    private Integer id;
    private String department;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "Department{" +
                "id=" + id +
                ", Department='" + department + '\'' +
                '}';
    }
}

设置mybatis 操作数据源类

@Mapper//指定这是一个操作数据库的Mapper
public interface DeparmentMapper {
    @Select("select * from department where id = #{id}")
    public Department findDepartById(Integer id);

    @Delete("delete from department where id = #{id}")
    public int deleteDepartById(Integer id);

    @Update("update department set department = #{department} where id = #{id}")
    public int updateDepartById(Department department);

    @Insert("insert into department(department) values(#{department})")
    public int insertDepart(Department department);
}

Controller（控制层）

@Controller
public class Test01 {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @Autowired
    DeparmentMapper deparmentMapper;

    @GetMapping("/hello")
    @ResponseBody
    public Map<String, Object> find(){
        List<Map<String, Object>> list = jdbcTemplate.queryForList("select * from department");
        return list.get(0);
    }

    @GetMapping("/depart/{id}")
    @ResponseBody
    public Department findDepart(@PathVariable("id") Integer id){
        Department department = deparmentMapper.findDepartById(id);
        return department;
    }

    @GetMapping("/depart")
    @ResponseBody
    public Department addDepart(Department department){
        deparmentMapper.insertDepart(department);
        return department;
    }
}

自定义mybatis 的配置规则；给容器中添加一个ConfigurationCustomizer

@Configuration
public class MybatisConfig {
    @Bean//把组件添加到容器中
    public ConfigurationCustomizer configurationCustomizer(){
        return new ConfigurationCustomizer() {//自定义配置定制器
            @Override
            public void customize(org.apache.ibatis.session.Configuration configuration) {
                //开启驼峰命名法
                configuration.setMapUnderscoreToCamelCase(true);
            }
        };
    }
}

主程序配置

@MapperScan("cn.zdxh.lcy.demo02.mapper")//批量扫描这个包下的mybatis配置文件 
@SpringBootApplication
public class Demo02Application {

    public static void main(String[] args) {
        SpringApplication.run(Demo02Application.class, args);
    }

}

使用xml 配置文件的方式操作mybatis
mybatis的相关操作可参考

设置mybatis的全局配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 配置版驼峰命名法 -->
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
</configuration>

设置JavaBean

public class Person {
    private Integer id;
    private String name;
    private Integer gender;
    private String email;
    private Integer d_id;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getGender() {
        return gender;
    }

    public void setGender(Integer gender) {
        this.gender = gender;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getD_id() {
        return d_id;
    }

    public void setD_id(Integer d_id) {
        this.d_id = d_id;
    }

    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", gender=" + gender +
                ", email='" + email + '\'' +
                ", d_id=" + d_id +
                '}';
    }
}

为JavaBean设置接口

public interface PersonMapper {
    public Person selectPerson(Integer id);

    public int insertPer(Person person);

    public int deletePer(Integer id);

    public int updatePer(Person person);
}

SQL文件


SET FOREIGN_KEY_CHECKS=0;

-- ----------------------------
-- Table structure for employee
-- ----------------------------
DROP TABLE IF EXISTS `person`;
CREATE TABLE `person` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `email` varchar(255) DEFAULT NULL,
  `gender` int(2) DEFAULT NULL,
  `d_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

配置SQL映射文件

<?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">
<!-- 把这里SQL配置文件映射到cn.zdxh.lcy.demo02.mapper.PersonMapper接口下 -->
<mapper namespace="cn.zdxh.lcy.demo02.mapper.PersonMapper">
    <select id="selectPerson" resultType="cn.zdxh.lcy.demo02.dao.Person">
        select * from person where id = #{id}
    </select>
    <insert id="addPeron">
        insert into person(name, gender, email, d_id) values(#{name}, #{gender}, #{email}, #{d_id})
    </insert>
    <update id="updatePerson">
        update person set name=#{name}, gender=#{gender}, email=#{email}, d_id=#{d_id} where id = #{id}
    </update>
    <delete id="deletePerson">
        delete from person where id = #{id}
    </delete>
</mapper>

在项目配置文件（application.properties）中设置mybatis配置信息

########################################
##设置mybatis的配置参数
mybatis:
  ##配置mybatis的全局配置文件
  config-location: classpath:mybatis/mybatis-config.xml
  ##设置SQL数据持久化映射文件
  mapper-locations: classpath:mybatis/mapper/*

8）、整合JPA（Java Persistence API）
JPA：ORM（Object Relational Mapping）
在这里插入图片描述

①、编写一个实体类（JavaBean）和数据表进行关联映射，并且配置好映射关系

//使用JPA朱俊杰配置映射关系
@Entity//告诉JPA这个一个实体类（和数据表关联映射的类）
@Table(name = "tab_user")//指定和“tab_user"这个数据表对应，如果省略默认表名就是user
public class User {
    @Id//标注该注解标明此属性为数据表的主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)//设置属性值自增
    private Integer id;

    @Column(name = "username", length = 255)//设置数据表的普通字段列名
    private String username;
    @Column//省略默数据表认列名就是属性名
    private String password;
    @Column
    private String email;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

②、编写一个对User实体类的操作接口（已经有基本CRUD操作了）

//JpaRepository 来完成对数据库的操作
public interface UserRepository extends JpaRepository<User, Integer> {//泛型中一个是实体类名， 一个是主键类型
}

设置jpa的基本配置参数

spring：
	jpa:
	    hibernate:
	      #更新或者创建数据表结构
	      ddl-auto: update
	    #显示SQL语句
	    show-sql: true

设置一个Controller层处理类

@RestController//@ResponseBody + @Controller
public class UserController {
    @Autowired
    UserRepository userRepository;

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable("id") Integer id){
        User user = userRepository.findOne(id);//通过id向数据表查询单行值
        return user;
    }

    @GetMapping("/user")
    public User addUser(User user){
        User save = userRepository.save(user);//向数据表插入单行值
        return save;
    }
}