【Spring】Spring入门

Spring 入门

Spring 全家桶

• Spring Framework —— Spring 框架 ， 基石
• Spring Boot —— 构建项目
• Spring Cloud —— 微服务
• Spring Cloud Data Flow —— 数据集成

官网

本项目只用 Spring Framework 和 Spring Boot

Spring Core ： Spring IoC

依赖注入， 实现的 IoC Container， 依赖注入的关键， 本质上是一个工厂。(我想到了 依赖倒置原则。)

Spring 容器 管理 Bean 的装配手段 （获取 Bean）

// Spring 容器 装配 Bean 的 基本方式
//定义 接口 Alpha 和 实现类 AlphaDaoHibernateImpl 、 AlphaDaoMyBatisImpl
/**
* 注解说明：
* @Repository —— 该 类是 数据库 相关 @Repository("Bean_name") —— 指定该 Bean 的名字
* @Primary —— 若一个 interface 有多个 implements class， 被该注解声明的类（Bean） 将被 Spring 容器 优先装配
*/
public interface AlphaDao {
    String select();
}

@Repository("alphaHibernate") // 自定义这个 bean 的名字 为 alphaHibernate， 通过 getBean 指定 name 字段 获取 特定的 接口实现类
public class AlphaDaoHibernateImpl implements AlphaDao {
    @Override
    public String select() {
        return "J+Hibernate";
    }
}

@Repository
@Primary // 该实现类 优先装配
public class AlphaDaoMyBatisImpl implements AlphaDao {
    @Override
    public String select() {
        return "MybatisImpl";
    }
}

// Test 测试类 ... 省略类 定义， 直接给出 测试方法
/**
* 方法说明： getBean()
* applicationContext.getBean(xxx.class); —— 装配 xxx （或其主实现类）
* applicationContext.getBean( "alphaHibernate", AlphaDao.class); —— 装配 xxx 的实现类，Bean 名为 alphaHibernate
*/
// applicationContext 是 Spring 容器的实例化对象
@Test
public void	testApplicationContext() {
    System.out.println(applicationContext);

    AlphaDao alphaDao = applicationContext.getBean(AlphaDao.class);
    System.out.println(alphaDao.select());

    // alphaDao = applicationContext.getBean( name: "alphaHibernate", AlphaDao.class); // 视频里是这样写的， 但我下面这样也成功
    alphaDao = applicationContext.getBean( "alphaHibernate", AlphaDao.class);
    System.out.println(alphaDao.select());

}

Spring 容器 管理 自定义 Bean 的构造和销毁

被 Spring 容器 管理的 Bean 默认是 单例的 @Scope("Singloten")

修改其单例属性只需要在 class 定义前加 @Scope("prototype") 注解

// 自定义 Bean  —— AlphaService
/**
* 注解说明 —— 类：
* @Service —— 该类是 业务组件
* @Scope("prototype") —— 修改 类（Spring 容器管理）， 使其不是 单例类
*/
/**
* 注解说明 —— 方法：
* @PostConstruct —— 该方法 在构造函数后 调用
* @PreDestroy —— 该方法 在销毁对象前 调用
*/
@Service // 业务组件用这个 注解
//@Scope("prototype") // 让 Bean 不是单例
public class AlphaService {
    // 构造函数
    public AlphaService() {
        System.out.println("实例化AlphaService");;
    }
	
    @PostConstruct // 在 构造之后调用 此初始化方法
    public void init() {
        System.out.println("初始化AlphaService");
    }

    @PreDestroy
    public void destory() {
        System.out.println("销毁AlphaService");
    }
}
// Test 测试类 ... 省略类 定义， 直接给出 测试方法
/**
* 测试说明： 如果没有 指定 @Scope("prototype")； 则 下述写出的两个 对象构造过程 实际上只会执行一次对象构造 —— 单例效果。
* 依次输出 ： 实例化AlphaService —— 初始化AlphaService —— 销毁AlphaService
*/
@Test
public void	testBeanManagement() {
    AlphaService alphaService = applicationContext.getBean(AlphaService.class);
    System.out.println(alphaService);

    alphaService = applicationContext.getBean(AlphaService.class);
    System.out.println(alphaService);
}

Spring 容器中装配第三方 Bean

应用场景 ： 在 项目中引用 第三方库 的 Bean

// 定义 配置 类 AlphaConfig 导入 第三方库中的 Bean —— 这里用 java 的 SimpleDateFormat
/**
* 注解说明：
* @Configuration —— 这是一个普通的配置类 （基于 Component 实现）
* @Bean —— 装配 第三方 Bean 或 自定义 Bean
*/
@Configuration // 表示 配置类
public class AlphaConfig {
    // 导入 官方Bean SimpleDateFormat
    @Bean
    public SimpleDateFormat simpleDateFormat() { // Bean 名就是 这个方法名
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // 这是一个 官方的 Bean
    }
}
// Test 测试类 ... 省略类 定义， 直接给出 测试方法
@Test
public void testBeanConfig() {
    SimpleDateFormat simpleDateFormat =
        applicationContext.getBean(SimpleDateFormat.class);
    System.out.println(simpleDateFormat.format(new Date()));
}

使用 依赖注入 直接获取 Bean 的方式 —— 推荐

// Test 测试类 ... 省略类 定义， 直接给出 主要内容 及 测试方法
/**
* 注解说明：
* @Autowired —— 直接 声明 Bean 对象 ，将其注入到 Spring 容器中
* @@Qualifier("alphaHibernate") —— 如果 Bean 有多个实现类， 通过参数传递 指定实现类 
*/
@Autowired // 使用 依赖注入 直接 获取 Bean， 不需要上述 的 操作
@Qualifier("alphaHibernate") // 指定 实现类
private AlphaDao alphaDao;

@Autowired
private AlphaService alphaService;

@Autowired
private SimpleDateFormat simpleDateFormat;

@Test
public void testDI() {
    System.out.println(alphaDao);
    System.out.println(alphaService);
    System.out.println(simpleDateFormat);
}

controller 调用 service， service 调用 dao —— 依赖注入的综合示例

controller —— 定义请求接口， 调用 service

service —— 业务实现层， 调用 dao

dao —— 数据处理层， 调用数据库

// 模拟一个上述 接口请求 到 返回数据 的过程， 返回一个 String 模拟数据库数据
// 调用：
// 浏览器地址栏输入： localhost:8080/alpha/data

/**
* controller.AlphaController
* 注解说明：
* @Controller —— 这是一个 接口定义类
* @RequestMapping("url_path") —— 请求的 url
* @ResponseBody —— 实际请求的 执行方法
*/
@Controller
@RequestMapping("/alpha")
public class AlphaController {
    @Autowired
    private AlphaService alphaService;

    @RequestMapping("/data")
    @ResponseBody
    public String getData() {
        return alphaService.find();
    }
}

/**
* service.AlphaService
*/
@Service
public class AlphaService {
	// ...
    @Autowired
    private AlphaDao alphaDao;

    public String find() {
        return alphaDao.select();
    }
}

/**
* dao.AlphaDao —— interface 
* 两个 implements class : AlphaDaoHibernateImpl (name: alphaHibernate)  —— 省略不在这里列出
* AlphaDaoMyBatisImpl (@Primary)
*/
public interface AlphaDao {
    String select();
}

@Repository
@Primary
public class AlphaDaoMyBatisImpl implements AlphaDao {
    @Override
    public String select() {
        return "MybatisImpl";
    }
}

/**
* main
*/
@SpringBootApplication // 自动配置 并生成 spring 容器， 不需要手动生成
public class CommunityApplication {
	public static void main(String[] args) {
		SpringApplication.run(CommunityApplication.class, args);
	}
}