springboot3+dubbo+zookeeper+总结

异步任务：

定时任务：表达式：TaskExecutor，TaskScheduler

邮件发送：时间

一、异步任务

实现方法：

1、

@Service
public class AsyncService {
    //告诉Spring这是一个异步的方法
    @Async
    public void hello(){
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("数据正在处理");
    }
}

2、

@RestController
public class AsyncController {
    @Autowired
    AsyncService asyncService;
    @RequestMapping("/hello")
    public String hello(){
        asyncService.hello();//停止3s
        return "ok";
    }
}

3、

@EnableAsync//开启异步注解功能
@SpringBootApplication
public class Springboot09TestApplication {

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

}

二、邮件任务

1、导入依赖

        <!--javax.mail-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-mail</artifactId>
            <scope>test</scope>
        </dependency>

2、QQ邮箱授权码：eddn wkio ydlk bahi

3、在配置文件中设置

spring.mail.username=706915503@qq.com
spring.mail.password=eddnwkioydlkbahi
spring.mail.host=smtp.qq.com
#开启加密验证
spring.mail.properties.mail.smtp.ssl.enable=true

4、测试

class Springboot09TestApplicationTests {
    @Autowired
    JavaMailSenderImpl javaMailSender;

    @Test
    void contextLoads() {
        //一个简单的邮件
        SimpleMailMessage simpleMailMessage = new SimpleMailMessage();
        simpleMailMessage.setSubject("hello,aurora");
        simpleMailMessage.setText("thanks for yourself");
        simpleMailMessage.setTo("rchx1314@163.com");
        simpleMailMessage.setFrom("706915503@qq.com");
        javaMailSender.send(simpleMailMessage);
        System.out.println("发送成功");
    }
    @Test
    void contextLoads2() throws MessagingException {
        //一个复杂的邮件
        MimeMessage mimeMessage = javaMailSender.createMimeMessage();
        //组装
        MimeMessageHelper mimeMessageHelper = new MimeMessageHelper(mimeMessage,true);
        mimeMessageHelper.setSubject("aurora,one");
        mimeMessageHelper.setText("<p style=‘color:red‘>thanks</p>",true);
        mimeMessageHelper.addAttachment("1.jpg",new File("C:\\Users\\Aurora\\Desktop\\1.jpg"));
        mimeMessageHelper.setTo("rchx1314@163.com");
        mimeMessageHelper.setFrom("706915503@qq.com");
        javaMailSender.send(mimeMessage);
        System.out.println("发送成功");
    }

}

三、定时任务

TaskExecutor
TaskScheduler
@EnableSchedualing//开启定时功能的注解
@Scheduled//什么时候执行
Cron表达式

四、SpringBoot整合

springboot操作数据：spring-data jpa jdbc mongodb redis

springdata也是和springboot齐名的项目

说明：在SpringBoot2.x之后，原来使用的jedis被替换为了lettuce

jedis：采用的是直连，多个线程操作是不安全的，如果想要避免，使用jedis pool连接池，更像BIO模式

lettuce：采用netty，实例可以在多个线程中共享，不存在线程不安全的情况，可以减少线程数据了，更像NIO模式

#SpringBoot所有配置类，都有一个自动配置类RedisAutoConfiguration
#自动配置类都会绑定一个Properties配置文件RedisProperties

源码分析：

@Bean
@ConditionalOnMissingBean(
    name = {"redisTemplate"}
)//我们可以自己定义一个redisTemplate来替换默认的
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    //默认的RedisTemplate没有过多的设置，redis对象都需要序列化
    RedisTemplate<Object, Object> template = new RedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

@Bean
@ConditionalOnMissingBean
@ConditionalOnSingleCandidate(RedisConnectionFactory.class)
//由于String类型是Redis中最常使用的类型，所以单独提出来一个bean
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

• 1、导入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

• 2、配置连接

  spring.redis.host=127.0.0.1
  spring.redis.port=6379

• 3、测试

@SpringBootTest
class Redis02SpringbootApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void contextLoads() {
        //操作不同数据类型，api和我们的指令是一样的
        //opsForValue操作字符串，类似String
        //opsForList操作list，类似List
        //获取redis的连接对象
        //RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
        //connection.flushAll();
        //connection.flushDb();
        redisTemplate.opsForValue().set("aurora","eternity");
        System.out.println(redisTemplate.opsForValue().get("aurora"));
    }
}print doge to the moon！！！

自定义RedisTemplate：

@Configuration
public class RedisConfig {
    //编写我们自己的redisTemplate
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        //默认的RedisTemplate没有过多的设置，redis对象都需要序列化
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

五、分布式Dubbo+Zookeeper+SpringBoot

什么是分布式系统？

什么是RPC？

RPC是远程过程调用（Remote Procedure Call）的缩写形式。SAP系统RPC调用的原理其实很简单，有一些类似于三层构架的C/S系统，第三方的客户程序通过接口调用SAP内部的标准或自定义函数，获得函数返回的数据进行处理后显示或打印。

Apache Dubbo 是一款微服务开发框架，它提供了 RPC通信 与 微服务治理 两大关键能力。这意味着，使用 Dubbo 开发的微服务，将具备相互之间的远程发现与通信能力， 同时利用 Dubbo 提供的丰富服务治理能力，可以实现诸如服务发现、负载均衡、流量调度等服务治理诉求。同时 Dubbo 是高度可扩展的，用户几乎可以在任意功能点去定制自己的实现，以改变框架的默认行为来满足自己的业务需求。

• zookeeper：注册中心
• dubbo-admin：是一个监控管理后台，查看我们注册了哪些服务，哪些服务被消费了
• Dubbo：jar包

1、创建项目provider-server

导入依赖

        <!--导入依赖Dubbo，Zookeeper-->
        <!-- https://mvnrepository.com/artifact/org.apache.dubbo/dubbo-spring-boot-starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.7.8</version>
        </dependency>
        <!--zkclient-->
        <!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient -->
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.curator/curator-recipes -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>4.2.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.apache.zookeeper/zookeeper -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.14</version>
            <!--排除这个slf4j-log4j12-->
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

2、配置文件

server.port=8081
#服务应用名字
dubbo.application.name=provider-server
#注册中心地址
dubbo.registry.address=zookeeper://127.0.0.1:2181
#哪些服务要被注册
dubbo.scan.base-packages=com.aurora.service

3、注册

//服务注册与发现
@Service//可以被扫描到，在项目已启动就自动注册到项目中心
@Component//使用Dubbo后尽量不要用@Service注解
public class TicketServiceImpl implements TicketService{
    @Override
    public String getTicket() {
        return "aurora";
    }
}

4、启动zookeeper服务

5、启动服务端项目

6、配置客户端项目

• 导入依赖
• 引用服务端，在同一个目录下引入接口，实现调用

import org.springframework.stereotype.Service;

@Service//放到容器中
public class UserService {
    //想拿到provider提供的票
    @Reference//引用，pom坐标，可以定义路径相同的接口名
    TicketService TICKET_SERVICE;
    public void buyTicket(){
        String ticket = TICKET_SERVICE.getTicket();
        System.out.println("在注册中心拿到=>"+ticket);
    }
}

• 测试

@SpringBootTest
class ConsumerServerApplicationTests {
    @Autowired
    UserService userService;

    @Test
    void contextLoads() {
        userService.buyTicket();
    }

}

步骤：

1、提供者提供服务：

• 导入依赖
• 配置注册中心地址，以及服务发现名，和要扫描的包
• 在想要被注册的服务上面，增加一个注解@Service，注意是Dubbo下的注解

2、消费者如何消费

• 导入依赖
• 配置注册中心地址，配置自己的服务名
• 从远程注入服务@Reference

六、回顾

三层架构+MVC
架构-->解耦
开发框架：
	spring：
		ioc aop：
			ioc控制反转，容器
			aop切面（本质，动态代理），不影响业务本来的情况下，实现动态增加功能，大量应用在日志，事务中
		spring是一个轻量级java开源框架，容器
		目的：解决企业开发复杂性问题
		spring配置文件过于复杂
		springboot应运而生
	springboot：
		新一代javaEE开发标准，开箱即用，自动配置了许多东西
		springboot是spring升级版，简化了spring
		特性：约定大于配置
随着公司体系越来越大，用户越来越多
	微服务架构诞生
新架构：
	模块化，功能化
	用户，支付，签到，娱乐
	人过于多，一台服务器解决不了，只能增加服务器，横向
	服务器负载均衡
	将原来整体项目模块化，用户就是一个单独项目，签到也是，项目和项目之间也需要通信，如何通信？
	用户过多，而签到十分少，给用户多一点服务器，签到少一点
微服务架构问题？
	分布式架构四个核心问题：
		1、这么多服务，客户端怎么去访问？
		2、服务之间如何通信？
		3、这么多服务，如何治理？
		4、服务挂了，怎么办？
	解决方案：
		1、springcloud是一套生态，解决以上分布式架构的四个问题，但是想使用springcloud必须要掌握springboot，因为springcloud是基于springboot
		spring cloud netflix，出来了一套解决方案，一站式解决方案，我们都可以直接去这里拿
			api网关，zuul组件
			http：feign-->httpclient-->http的通信方式，同步并阻塞
			服务注册与发现，eureka
			熔断机制，hystrix
			netflix停止维护
		2、Apache Dubbo zookee第二套解决系统
			API：没有，要么找第三方组件，要么自己实现
			Dubbo是一个高性能的基于java实现的RPC通信框架
			服务注册与发现，zookeeper（hadoop，hive）
			没有熔断，借助hystrix
		3、springcloud alibaba 一站式解决方案
	目前又提出一种方案：
		服务网格：下一代微服务标准，server mesh
		代表方案：istio
	万变不离其宗：
		1、API网关，服务路由
		2、HTTP,RPC框架，异步调用
		3、服务注册与发现，高可用
		4、熔断机制，服务降级
		本质问题：网络不可靠
	

springboot3+dubbo+zookeeper+总结

原文：https://www.cnblogs.com/rongchengbanxia/p/15041481.html