Java 阶段三 Day09 Springboot及Mybatis概述

补充

单实例和多实例

• 单实例
  单实例（Singleton）是指某个类只能创建唯一的一个实例对象，并且该类提供一个全局的访问点（静态方法）来让外界获取这个实例，常常用在那些只需要一个实例来处理所有任务的场景下，例如数据库连接。
• 多实例
  多实例（Multiple Instance）则是指可以在同一个类的定义下，创建多个实例对象。每个对象都是相互独立的，有自己的状态和行为；常常用于需要同时处理多个任务的场景。

应用分析

第1步：在 com.example.spring 下创建类 DBConnect

@Scope(value = "singleton")
@Component
public class DBConnect {
}

第2步：创建测试类进行测试

public class TestDBConnect {
	@Test
	public void testScope(){
		ApplicationContext context = new AnnotationConfigApplicationContext("com.example.spring");
		// 第一次获取
		DBConnect dbConnect1 = context.getBean(DBConnect.class);
		System.out.println(dbConnect1);
		// 第二次获取
		DBConnect dbConnect2 = context.getBean(DBConnect.class);
		System.out.println(dbConnect2);
	}
}

总结
当为单例模式 singleton 时，多次获取bean实例的地址是相同的

当为多例模式 prototype 时，多次获取bean实例的地址是不同的

单例模式适用于需要共享数据并且需要避免重复创建实例的情况。而多例模式适用于需要动态地创建对象并提供独立实例的情况。

Bean对象生命周期管理

程序中的每个对象都有生命周期，对象的创建、初始化、应用、销毁的整个过程称之为对象的生命周
期；
在对象创建以后需要初始化，应用完成以后需要销毁时执行的一些方法，可以称之为是生命周期方法；
在Spring中，可以通过 @PostConstruct 和 @PreDestroy 注解实现 bean对象生命周期的初始化和销
毁时的方法。

• @PostConstruct 注解
  生命周期初始化方法，在对象构建以后执行。
• @PreDestroy 注解
  生命周期销毁方法，比如此对象存储到了Spring容器，那这个对象在Spring容器移除之前会先执行
  这个生命周期的销毁方法（注：prototype作用域对象不执行此方法）。

完整生命周期

1. 实例化阶段（bean对象创建）
   在这个阶段中，IoC容器会创建一个Bean的实例，并为其分配空间。这个过程可以通过 构造方法
   完成。
2. 属性赋值阶段
   在实例化完Bean之后，容器会把Bean中的属性值注入到Bean中，这个过程可以通过 set方法 完
   成。
3. 初始化阶段（bean对象初始化）
   在属性注入完成后，容器会对Bean进行一些初始化操作；
4. 使用阶段
   初始化完成后，Bean就可以被容器使用了
5. 销毁阶段
   容器在关闭时会对所有的Bean进行销毁操作，释放资源。

生命周期验证

第1步： DBConnect 类中打印生命周期过程

@Scope(value = "singleton")
@Component
public class DBConnect {
	private String username;
	/**
	* 1.调用无参构造方法进行bean对象创建
	*/
	public DBConnect() {
		System.out.println("1-bean对象创建，调用无参构造");
	}

	/**
	* 2.通过setter()方法进行属性赋值
	*/
	@Value("root")
	public void setUsername(String username) {
		this.username = username;
		System.out.println("2-通过set方法给bean对象赋值");
	}
	/**
	* 3.对象创建后可以通过此方法进行初始化
	*/
	@PostConstruct
	public void init(){
		System.out.println("3-初始化阶段");
	}
	/**
	* 5.对象销毁前可以通过此方法进行资源释放
	*/
	@PreDestroy
	public void destroy(){
		System.out.println("5-bean对象销毁，释放资源");
	}
}

第2步：测试类中打印生命周期过程

public class TestDBConnect {
	@Test
	public void testScope(){
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("com.example.spring");
		DBConnect dbConnect = context.getBean(DBConnect.class);
		// 4.bean对象初始化完成，可以使用
		System.out.println("4-应用程序使用bean对象阶段");
		// 销毁bean
		context.close();
	}
}

生命周期扩展

Bean初始化和销毁方法可以在Bean生命周期的特定时机执行自定义逻辑，方便地对Bean进行管理和配置。

• 初始化常见应用场景
  • 创建数据库连接
  • 加载资源文件
  • 进行数据校验
• 销毁常见应用场景
  • 断开数据库连接
  • 保存数据
  • 释放占用的资源

引用外部属性文件

实际开发中，很多情况下我们需要对一些变量或属性进行动态配置，而这些配置可能不应该硬编码到我们的代码中，因为这样会降低代码的可读性和可维护性。
我们可以将这些配置放到外部属性文件中，比如 database.properties 文件，然后在代码中引用这些属性值，例如 jdbc.url 和 jdbc.username 等。这样，我们在需要修改这些属性值时，只需要修改属性文件，而不需要修改代码，这样修改起来更加方便和安全。
而且，通过将应用程序特定的属性值放在属性文件中，我们还可以将应用程序的配置和代码逻辑进行分离，这可以使得我们的代码更加通用、灵活。

使用流程

1. 创建外部属性文件（在resources目录下创建文件，命名为：“xxx.properties”）
2. 引入外部属性文件（使用 @PropertySource(“classpath:外部属性文件名”) 注解）
3. 获取外部属性文件中的变量值 （使用 ${变量名} 方式）
4. 进行属性值注入

应用分析

第1步：在 resources 目录下创建文件 ： database.properties

jdbc.user=root
jdbc.password=root
jdbc.url=jdbc://mysql://localhost:3306/test
jdbc.driver=com.mysql.cj.jdbc.Driver

第2步：工程目录下创建子包 file 并创建类 Database

• 通过 @PropertySource 注解引入外部文件
• 通过 ${变量名} 获取属性值
• 通过 @Value() 注解进行属性值注入

@Component
@PropertySource("classpath:database.properties")
public class Database {
	@Value("${jdbc.url}")
	private String url;
	@Value("${jdbc.user}")
	private String username;
	@Value("${jdbc.password}")
	private String password;
	@Value("${jdbc.driver}")
	private String driver;
	@Override
	public String toString() {
		return "Database{" +
			"url='" + url + '\'' +
			", username='" + username + '\'' +
			", password='" + password + '\'' +
			", driver='" + driver + '\'' +
			'}';
	}
}

第3步：创建测试类 TestDatabase 进行测试

public class TestDatabase {
	@Test
	public void testFile(){
		ApplicationContext context = new AnnotationConfigApplicationContext("com.example.spring");
		Database database = context.getBean(Database.class);
		System.out.println(database);
	}
}

自动扫描配置

自动扫描配置是 Spring 框架提供的一种基于注解（Annotation）的配置方式，用于自动发现和注册 Spring 容器中的组件。当我们使用自动扫描配置的时候，只需要在需要被 Spring 管理的组件（比如 Service、Controller、Repository 等）上添加对应的注解，Spring 就会自动地将这些组件注册到容器中，从而可以在其它组件中使用它们。

在 Spring 中，通过 @ComponentScan 注解来实现自动扫描配置。

@ComponentScan 注解用于指定要扫描的包或类。

Spring 会在指定的包及其子包下扫描所有添加 @Component （或 @Service 、 @Controller 、@Repository 等）注解的类，把这些类注册为 Spring Bean，并纳入 Spring 容器进行管理。

使用示例

@Configuration
@ComponentScan("com.example.spring")
public class AppConfig {
}

在此示例中，

• @Configuration 注解
  表示将类 AppConfig 标识为一个 Spring 配置类，Spring 会来加载此类，并且读取其中的配置。
• @ComponentScan 注解
  用于指定扫描的包路径 com.example.spring 。
  Spring 会自动在 com.example.spring 包及其子包下扫描所有被 @Component 等注解标注的类，并将这些类注册为 Spring Bean。

应用分析

第1步： 工程下创建包 config，并在此包下创建类 SpringConfig

/**
* @Configuration注解： 将类 SpringConfig 标识为一个 Spring 配置类
*/
/**
* @ComponentScan注解：指定要扫描的包路径 cn.tedu.spring，包含该包下的子包
*/
@Configuration
@ComponentScan("com.example.spring")
public class SpringConfig {
}

第2步：创建测试类 TestScan 进行测试

public class TestScan {
	@Test
	public void testScan(){
	// 指定配置类:SpringConfig
		ApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
		// 获取bean对象
		Database database = context.getBean(Database.class);
		System.out.println(database);
		// 获取bean对象
		UserCache userCache = context.getBean(UserCache.class);
		System.out.println("userCache = " + userCache);
	}
}

SSM

SSM 是一个常见的缩写，通常用于描述一种 Java 技术栈，它包括以下三个主要框架或库：

1. Spring：Spring 是一个开源的轻量级应用框架，用于构建 Java 应用程序。它提供了广泛的功能，包括依赖注入（Dependency Injection）、面向切面编程（Aspect-Oriented Programming）、事务管理、数据访问、安全性等。Spring 的目标是简化企业级应用程序的开发，提高代码的可维护性和可测试性。

2. Spring MVC：Spring MVC 是 Spring 框架的一部分，用于构建基于模型-视图-控制器（MVC）设计模式的 Web 应用程序。它提供了一个灵活且可扩展的方式来处理 HTTP 请求和响应，将请求映射到控制器方法，然后渲染视图以生成响应。Spring MVC 提供了强大的处理器映射、视图解析、数据绑定和验证功能，使开发 Web 应用程序变得更加简单。

3. MyBatis：MyBatis 是一个持久性框架，用于简化数据库访问。它允许开发人员使用 SQL 查询来操作数据库，并将查询结果映射到 Java 对象，从而使数据库交互更加方便。MyBatis 支持动态 SQL 查询、事务管理、缓存管理等功能，使数据库操作变得更加灵活。

组合使用 Spring、Spring MVC 和 MyBatis，可以构建一个完整的 Java Web 应用程序，通常称为 SSM 应用程序。这个组合提供了一种结构化的方法来开发企业级 Web 应用程序，并且在许多项目中都得到广泛应用。这些框架的结合使开发人员能够轻松处理业务逻辑、数据访问和用户界面，同时保持代码的可维护性和可测试性。

SpringBoot

Spring Boot 是一个用于快速构建基于 Spring 框架的应用程序的开源框架。它旨在简化 Spring 应用程序的开发和部署，提供了许多便捷的功能和约定，使开发人员能够更快速地构建生产就绪的应用程序。以下是 Spring Boot 的一些关键特点和优势：

1. 自动配置（Auto-Configuration）：Spring Boot 使用自动配置来减少开发人员的配置工作。它根据项目的依赖和环境自动配置应用程序，例如，如果你使用了 Spring Data JPA，Spring Boot 将自动配置数据源和 JPA 实体管理器。

2. 起步依赖（Starter Dependencies）：Spring Boot 提供了一系列称为 “起步依赖” 的预配置依赖项，用于简化特定类型应用程序的构建。这些起步依赖包含了常用的库和框架，并可以根据需要进行扩展。

3. 嵌入式 Web 服务器：Spring Boot 集成了多个嵌入式 Web 服务器，如Tomcat、Jetty 和Undertow，这意味着你可以将应用程序打包成可执行的 JAR 文件或 WAR 文件，并且不需要外部的 Web 服务器。

4. 生产就绪（Production-Ready）：Spring Boot 提供了许多特性，如健康检查、度量指标、外部化配置，以帮助你构建生产就绪的应用程序，并更容易地监视和管理它们。

5. 无代码生成和无 XML 配置：Spring Boot 倡导零配置原则，尽量减少代码生成和 XML 配置文件的使用。这使得应用程序更加清晰、简单，并且更容易维护。

6. 大型社区和生态系统：Spring Boot 拥有庞大的社区支持和丰富的生态系统，你可以轻松地找到解决问题的资源和插件。

Spring Boot 不仅适用于构建 Web 应用程序，还可以用于构建各种类型的应用程序，包括批处理、消息队列、RESTful 服务等。它使得 Spring 应用程序的开发变得更加快速和便捷，因此在 Java 开发社区中得到了广泛的应用。你可以使用 Spring Boot Initializer 来创建一个新的 Spring Boot 项目，选择所需的依赖项，并开始构建应用程序。

MyBatis框架-注解管理

概述

MyBatis 是一个用于简化 Java 数据访问层（Data Access Layer）的持久性框架。在 MyBatis 中，你可以使用注解来管理 SQL 查询和映射，而无需使用 XML 配置文件。注解管理使得 SQL 查询更紧凑、易读，并且能够更好地与 Java 代码集成。

MyBatis环境初始化

• 工程名：mybatis 选择Java 8版本

• SpringBoot版本：2.7.15

• 勾选3项依赖项

  • Spring Web
  • MyBatis Framework
  • MySQL Driver

整合MyBatis

application.properties配置文件中添加连接数据库信息

spring.datasource.url=jdbc:mysql://localhost:3306/数据库名?serverTimezone=Asia/Shanghai&characterEncoding=utf8
spring.datasource.username=数据库用户名
spring.datasource.password=数据库密码

Pojo对象设计

在工程目录中创建pojo包，并创建Weibo类

import java.util.Date;

public class Weibo {
    private Integer id;
    private String content;
    private Date Created;
    private Integer UserId;

    public Integer getId() {
        return id;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getCreated() {
        return Created;
    }

    public void setCreated(Date created) {
        Created = created;
    }

    public Integer getUserId() {
        return UserId;
    }

    public void setUserId(Integer userId) {
        UserId = userId;
    }

    @Override
    public String toString() {
        return "Weibo{" +
                "id=" + id +
                ", content='" + content + '\'' +
                ", Created=" + Created +
                ", UserId=" + UserId +
                '}';
    }
}

Dao接口设计

• @Mapper注解

  是由MyBatis框架提供，用于描述数据层接口，告诉系统底层为此接口创建其实现类，在实现类中定义数据访问逻辑，执行与数据库的会话(交互)

• @Insert注解

  使 MyBatis 框架根据接口方法的返回值和参数类型自动生成插入数据的代码

• @Select注解

  使 MyBatis 框架根据接口方法的返回值和参数类型自动生成查询数据的代码

• @Update注解

  使 MyBatis 框架根据接口方法的返回值和参数类型自动生成修改数据的代码

• @Delete注解

  使 MyBatis 框架根据接口方法的返回值和参数类型自动生成删除数据的代码

• 占位符 #{}

  #{} 是 MyBatis 框架中用来表示占位符的语法。

  在 @Insert 注解中，#{} 所代表的是一个占位符，它可以接受 Java 对象作为输入参数，并将其转换为预编译的 SQL 语句中的参数。使用 #{}可以帮助我们避免 SQL 注入等问题，同时也方便了参数的类型转换，让 SQL 写起来更加简单。

• @Param注解

  @Param用于指定参数名和参数值。

  在使用 MyBatis 进行 SQL 语句开发时，使用 @Param注解将方法参数映射到 SQL语句中需要的占位符上，这样做的好处是可以清晰地表达 SQL 语句中占位符的含义，更容易使用和维护 SQL 语句。

基于MyBatis规范设计用户数据访问接口，在工程目录下创建包mapper，并创建 WeiboMapper 接口

import com.liner.mybatis.pojo.Weibo;
import org.apache.ibatis.annotations.*;

import java.util.List;

@Mapper
public interface WeiboMapper {
    /**在微博表中插入数据*/
    @Insert("INSERT INTO weibo VALUES(NULL,#{content},#{created},#{userId})")
    int insert(Weibo weibo);

    /**查询所有微博信息*/
    @Select("SELECT * FROM weibo")
    List<Weibo> selectWeibo();

    /**根据微博id查询数据*/
    @Select("SELECT * FROM weibo WHERE id=#{id}")
    Weibo selectByWeiboId(int id);

    /**更新微博表数据*/
    @Update("UPDATE weibo SET content=#{content},created=#{created},user_id=#{userId} WHERE id=#{id}")
    int updateById(Weibo weibo);

    /**删除微博表数据*/
    @Delete("DELETE FROM weibo WHERE id=#{id}")
    int deleteById(@Param("id") Integer id);
}

测试类新建测试方法进行测试

/**自动装配*/
@Autowired
private WeiboMapper weiboMapper;

/**在微博表中插入数据-测试方法*/
@Test
void InsertWeibo(){
    Weibo weibo = new Weibo();
    weibo.setContent("今天天气真不错呀");
    weibo.setCreated(new Date());
    weibo.setUserId(1);
    weiboMapper.insert(weibo);
}

/**查询所有微博信息-测试方法*/
@Test
void selectWeiboTest(){
    System.out.println(weiboMapper.selectWeibo());
}

/**根据微博id查询数据*/
@Test
void selectByWeiboIdTest(){
    System.out.println(weiboMapper.selectByWeiboId(2));
}

/**更新微博表数据-测试*/
@Test
void updateById(){
    Weibo weibo = new Weibo();
    weibo.setId(1);
    weibo.setContent("这是我修改后的微博");
    weibo.setCreated(new Date());
    weibo.setUserId(1);

    System.out.println(weiboMapper.updateById(weibo));
}

/**删除微博表数据-测试*/
@Test
void deleteByIdTest(){
    System.out.println(weiboMapper.deleteById(1));
}

注：insert、update、delete返回值为受影响的数据条数int。