首页 > 经验记录 > java ( 第 2 页)

 

微服务架构有一个问题,那就是客户端如何访问各个微服务。

总不能在客户端APP/HTML写很多个不同的地址来请求吧?这样维护及其困难、开发不易。

这时候就需要一个网关,客户端的请求都发给这个网关, 然后由他来给你路由到别的微服务里边。

netflix 就开源了一个微服务网关:Zuul ,可以和 SpringCloudNetflix 全家桶(Eureka、Ribbon、Hystrix等)完美集成。

 

废话不多说.代码撸起来。

首先,项目创建,当然,创建的还是我那个Gradle搭的SpringCloudFinchley项目的子模块。

这回不用加什么依赖,只需要一个Zuul的依赖和Eureka Client的依赖就够了。

而且Zuul自己本身就集成了Ribbon和Hystrix,非常强大。

build.gradle:

 

然后在Application启动类上边加上@EnableZuulProxy 用以声明zuul代理

最主要的: 配置类yml文件

既然这个 zuul 是提供一个服务路由的功能,又已知 zuul 完美的集成了 Eureka。可以从Eureka Server中得到所有注册进去的服务。

那么,最需要进行配置的。自然是访问路径所对应的服务啦, 在zuul这个服务的配置文件里,专门有个地方给你写这个路由规则( zuul.routes )

我的配置文件:

 

虽然我这个配置文件里注释已经写得挺详细了,但还是简单的解释一下:

zuul.routes 这个属性树下面第一级节点,即我写的local-router、user-router 等,这一级只是让你写个路由规则的名字。 瞎写就行。

再下一级,大致可以分为两种:

1、路由到其余微服务的 指定好 service-id(即服务注册进Eureka的服务名) 和对应的访问路径就行了 ( 例如: 我用户微服务有个API请求路径是 user/{id},我现在就可以通过 ZUUL_ADDRESS:ZUUL_PORT/zuul_user/user/{id} 来访问我sc-demo-microservice-user中的API)。

 2、路由到本地由Zuul自己进行处理的 指定好客户端访问路径,和对应的本地API地址( forward: +本地API的地址) 就行

 

到这步,其实Zuul这个服务就搭建完毕了, 已经可以使用了。而且,不但可以帮你进行服务路由,还会用自带的Ribbon给你的请求进行负载均衡。

 

搭建完了,当然还不够,还能让这个 zuul 服务更加强大

zuul的路由功能是基于他自己编写的一大堆过滤器实现的,这里先简单说下他的过滤器类型

他主要有四大标准过滤器类型,这四种是最主要的

1、PRE  在请求被路由之前调用这个过滤器

2、ROUTING 这个过滤器将请求路由到微服务

3、POST 这个过滤器在路由到对应微服务之后再执行

4、ERROR 出错时进的

 

zuul 他自己有这几个过滤器的实现,当然,他写的我不动他,我可以自己额外写过滤器来实现自己的功能嘛。

zuul过滤器的实现非常简单,只要继承 ZuulFilter 这个类就完事了。

我写了个日志记录的过滤器:

这几个方法不多说,看下ZuulFilter源码的注释就知道具体是什么意思了。反正就是关于你写的过滤器的设置(类型、执行顺序、是否执行、具体逻辑)

我这过滤器很简单,就记录一下请求方法、地址,是个PRE类型的过滤器,会在路由之前调用。过滤器能干的事情很多,认证啊、加密啊啥的都行,看业务需求了。

 

 

阅读全文

上个文章使用了Eureka搭建了集群服务注册中心,但是最后实现 RPC 的方式还是  从代码中获得服务对应地址->字符串拼接->请求获得响应  的这样一种方式。

这种方式弊端还是有不少的。如果可以像调用自己的服务一样调用别人提供的服务那该多舒适啊。

 

而 Feign 就可以实现这种需求,Feign也是网飞开发的,SpringCloud 使用 Feign 非常简单,我下边演示一下:

首先 服务消费者这边肯定需要一个对应的依赖:

需要启用Feign的话,也得在启动类上面加个注解 @EnableFeignClients

然后,创建一个 Feign 的接口,像这样子

@FeignClient 注解里边的默认属性,也就是name属性是一个客户端的名字,如果使用了Eureka的话,会给他自动解析为 Eureka Server 服务注册表中的服务。

要是配了Ribbon,也会使用默认的负载均衡策略来执行请求。

Feign默认使用SpringMVC的注解声明请求,当然也可以用Feign自带的注解。不过没啥必要,还需要配置东西。

 

我上边这个例子写完了,实际使用的话只需要注入该类然后调用对应的方法就完事了。非常简便。

不过有几个点需要注意

在使用@FeignClient 声明的Feign伪装类中:

使用 @PathVariable 注解,必须加上参数!

GET请求无法使用对象作为入参! 要不有多少参数写多少参数(每个都要加@RequestParam(“参数名”) 注解),要不就用接受一个Map对象,也得加@RequestParam

POST请求可以接收对象,需要加上@RequestBody注解

 

 

Feign论使用的话,其实已经差不多了。

但是还有一些相关的操作也比较重要。

 

Feign 的请求都是使用的默认配置,我们其实可以实现自己的配置供 Feign 使用以实现编码、解码、日志记录、验证 等等等等。

比如我可以这么定义一个配置类:

该类配置了对应的日志记录器,和一个简单的效验,以应对请求的验证。

在对应的Feign伪装类中,上边的@FeignClient注解改一下,就可以使用自己写的配置:

之所以在 @FeignClient 注解中指定配置,是因为我的配置类是没有加 @Configuration 注解的,我想要实现细粒度的控制。 推荐这样做。

如果加了@Configuration 注解,则 Spring 会将其自动解析自动应用到全局,这样子就不方便为每个请求进行细粒度调整。

 

 

阅读全文

上一篇 Spring Cloud 项目的搭建文章 : 链接

 

再说下我的版本号 , 用的比较新:

 

Spring Boot 2.0.5 RELEASE

Spring Cloud Finchley.SR3

项目管理工具: gradle


进入正题:

从之前的项目构造来看,RPC虽然是实现了,但是调用的链接确是写死在代码中的,比较丑陋。

要是提供服务的地址突然换了,那这边消费者直接雪崩,只能更改代码重新部署。而且无法实现负载均衡,这在一个微服务架构中是很不合理的。

要解决这问题,作为服务消费者,必须要有一个牛逼的服务发现机制。

Spring Cloud 就提供了多种服务发现组件的支持。Eureka、ZooKeeper 等,我这就用 Eureka 了, 在 Spring Cloud 这个生态圈里Eureka是比较流行的。

Eureka是网飞(Netflix)开源的服务发现组件。有Server和Client两部分,按需使用就行,我这就使用他们来构建一个高可用的服务注册中心。

 

我先把之前父模块的的Mybatis、mysql依赖给去了,放到了实际的微服务中(user/movie)。因为Eureka服务不需要这几个依赖,要是加载了mysql依赖会自动连接mysql,不加mysql的配置就会报一堆错误。

 

既然 Eureka 也是个服务,那当然也得在父模块下创建一个Eureka子模块。和其余的模块创建相同,没什么好说的。

给 Eureka 服务注册中心模块加上这个 Eureka Server 依赖

compile(“org.springframework.cloud:spring-cloud-starter-netflix-eureka-server“)

然后在 Eureka 服务的入口 java 文件上加上该注解 @EnableEurekaServer , 这个Application就是完全体了。

 

此时可以在网页里通过 ip:port 来访问页面,可以得知注册中心的状态、多少服务链接到本机。

 

Eureka Server 端写完后,需要注册的服务则需要导入Eureka的Client依赖,就是这个:

compile(“org.springframework.cloud:spring-cloud-starter-netflix-eureka-client“)

然后只要在yml文件中配置好要连接的服务注册中心的地址就完事了,其实此时一个服务注册发现功能已经可以完成了。

但是还不够,需要考虑到若是 Eureka Server 端突然宕掉,那么整个系统就会出问题。

客户端虽然会有相应的缓存(服务注册时会将Server端储存的数据拿到本地缓存),但是在此时若是其他的服务发生变更,靠缓存中的信息去请求就不正确了。

 

所以,想要高可用的一个服务注册中心,则需要搞一个集群。宕掉一个,还有另外的,这样容错率将大大提高。

其实Eureka搞集群非常简单。不过是开启两个实例,A实例注册进B实例,B实例注册进入A实例而已。

只需要使用两种不同的配置即可。(你要是想开五个就是五个不同的配置,看着加就完事了)

像我这样,我这是写在一个yml文件里了,用“—”来隔开,要是配置比较多是可以另起一个文件的,就叫application-xxx.yml。

可以使用 –spring.profiles.active=xxx 来启动不同的服务。

(这里有部分Security的配置,下面就讲)

在IDEA里边,可以使用这种方式来启动不同的实例:

集群也搭完了,启动第一个Eureka Server时可能会出点连接错误,不过不影响启动,这是因为第二个Server还没启动起来,而配置里需要它注册进去导致的,第二个启动起来后就没错误了。

你要是一下子就从网页进去看Eureka的状态,可能会出现红色粗体的:EMERGENCY! EUREKA MAY BE INCORRECTLY CLAIMING INSTANCES ARE UP WHEN THEY’RE NOT. RENEWALS ARE LESSER THAN THRESHOLD AND HENCE THE INSTANCES ARE NOT BEING EXPIRED JUST TO BE SAFE.

这个是Eureka的自我保护机制导致的。Eureka Server和Client之间每隔一段时间会进行一次心跳通信,告诉Server,Client还活着。要是某一段时间Server感觉自己这边少了几个心跳就会出这问题,只要不是真的你服务宕掉了,过一会就好了。

 

配置完毕后,客户端也只需要在配置文件中写两个链接就行,用逗号隔开。其实写一个也可以,因为Eureka集群会自动同步其他Eureka的注册信息。但还是推荐写俩,就是怕某些极端情况发生。

 

此时集群已经搭建完毕。客户端也可以连接得上,但是,这些端口就这样暴露出来也是很不科学的。攻击者可以轻易地得到你的服务信息。

最好的,当然还是加个验证啦!用户名密码这种验证永远不过时哈。

搭建完集群后,用 Spring Security 为 Eureka 增加 Basic 安全认证就很不错了!

只需要在 Eureka Server这边添加 Spring Security 的依赖就够了,Client端不用。

compile(“org.springframework.boot:spring-boot-starter-security“)

 

添加Security的依赖后就会自动开启验证,不用配置。用户名和密码的设定就像上边文件一样,只需要这样就行。

 

配置完用户名和密码后,连接Eureka Server自然就需要用到这些用户名和密码。

本来连接Server的的URL:   http://ip:port/eureka/

现在连接Server的的URL:   http://username:password@ip:port/eureka/

就算是从网页查看状态,也需要输入用户名和密码了哦。

 

Client端最终配置文件如下(反正配置都长得差不多,我这就放其中一个服务的文件就行了):

 

这样,其实应该就完事了,但是,在2.x版本的 Spring Security 中,引入依赖后,自动开启CSRF安全认证。

任何一次服务请求默认都需要CSRF 的token , 而我区区一个小Client,哪里来的这种东西。就是Eureka Server 自注册都会挂掉。

那么还是要让 Security 的CSRF拦截自动忽略掉注册Eureka的链接比较好。

在 Eureka Server 端增加这么一个配置类:

这样子去除 /eureka/  这个连接的 CSRF 效验。就都可以连接上了。

 

OK 整体 Eureka 注册中心都搭建完毕了。并且实现了集群高可用和安全策略,比较完善。

 

服务之间的调用在做一点点微小的改进:

 

通过 DiscoveryClient 这个类,可以获取到对应服务的信息,这里我便是用 movie 服务获取到了user 服务的 url  来进行的调用。

当然,就算是这样,也不是那么的方便,关于feign声明式调用之后也会写篇文章的。

 

我的项目地址: github

阅读全文

看下这样一段代码:

我在一个方法中建立了个死循环,循环的判断条件为一个boolean类型的成员变量。

然后在main线程中,创建了一个新的名为 “t1” 的线程,去执行这个方法。

等待一秒后,mian线程自身,将该成员变量的值改为false,试图使其不满足条件从而循环终止。

按照正常的逻辑来说,按照脑海中预演的情况来说,应该是没问题的。

可是执行后却没有得到想要的结果,控制台输出 “start” 后再无反应,程序一直没有终止,即 死循环没有退出。

 

想要让程序正确执行的话,将定义语句 boolean flag = true; 改为 volatile boolean flag = true;  程序就可以正确执行,这是为什么呢?

 

这里要涉及一点 java 内存模型,JMM。

JMM 里头,他有分配一块内存,叫主内存。类比于操作系统中的主存,主要存放线程间的共享数据(除去方法参数、局部变量)。

然后,每个线程在执行的过程当中,都有一个WorkingMemory,是主内存中部分数据的副本,只能该线程访问,类比于硬件的高速缓存。线程对数据的访问通常只能在workingMemory中进行,不能直接与主存交互。

比如cpu运行多个不同的线程的话,每个线程都有一个WorkingMemory,cup就是将主内存里边的数据读过来读到WorkingMemory里,然后再进行修改,比如+1+1+1+1,修改完后,再给他写回内存去。

 

我上边写的代码,这几个线程是怎么执行的呢?

在我的代码中,flag 是存在于堆内存中的 v 对象中。

当线程 t1 开始跑后,它首先会从主内存中把这个 flag 变量给它 copy 到自己的工作内存里边,然后开始运行。在cpu处理的过程之中,由于这cpu处理这个线程的部分他非常的忙,一直在while循环嘛,就不再去读主内存里边的数据了,一直在读自己的缓冲区(线程的工作内存)。

main 线程,改flag的参数,也是把 flag 参数 true 给读到自己的工作内存里边,然后进行修改,修改完事后,发现自己工作内存中的数据和主存中不一致,于是将自己工作内存中的数据给他刷新到主存中去。

这个时候就有问题了。第一个线程没有在主存里重新读啊?所以,这时候第一个线程就结束不了。

 

 

volatile 关键字功能及作用:

简单的来说,volatile 关键字,主要功能是使一个变量在多个线程间可见。

volatile关键字修饰的变量一旦在主存中被改变时,就会通知别的使用到该变量的线程:你们的缓冲区中的内容过期了,需要再重新刷新一下。

以上面那个代码例子来说 ,这样定义语句 volatile boolean flag = true;

当 main 线程修改主内存中 flag 的值时。这个时候, t1 线程,就会去重新读一遍主存,刷新自己的缓冲区(工作空间)。此时 t1 线程中的 flag 刷新为 false ,故循环停止。程序运行完毕。

 

虽然 volatile 用起来比较简单,但是该关键字背后代表的逻辑还是很深的。

 

 

还有个点要注意:

volatile并不能保证多个线程共同修改某一变量时所带来的不一致问题,也就是说 volatile 不能代替 synchronized。

当然, volatile 的效率高 synchronized 很多倍。但是该上锁的时候也只能上锁。

synchronized 是 既有可见性,又保证原子性。而 volatile 只保证可见性。synchronized的实现也是比 volatile 更重的。

 

 

关于 synchronized  本来也有一篇文章要写的。想想还是算了,本来想写点加锁释放锁的原理、可重入性质和可见性和原理啥的。

不过我过了归纳的那一段时间了,现在想归纳总结一通怪麻烦的。反正这些知识脑子里都有,就不记录了。

 

阅读全文

WebSocket一次握手就可以使客户端和服务端建立长连接,并进行双向数据传输。

由于其双向传输特性,服务端可主动向客户端发送信息,实时性很高。

而与HTTP协议比起来WebSocket 协议每次数据传输的头信息都较小,节约带宽。

在获取实时数据这方面时,那是比ajax轮询方式高到不知道哪去了。

 

在SpringBoot架构下进行WebSocket服务开发的话,首先还是要导入这个

就算是使用Tomcat 7 的@ServerEndpoint进行 WebSocket开发,也得导。不然在SpringBoot环境下会有bug。

普通java web应用开发WebSocket就不需要了,@ServerEndpoint直接用就行。

maven仓库: spring-boot-starter-websocket

 

这是使用@ServerEndpoint进行的传统WebSocket开发:

由于我是在SpringBoot环境,所以得先写个能扫描@ServerEndpoint的配置,不然在客户端连接的时候会一直连不上。不是在SpringBoot下开发的可以跳过这一环节。

ServerEndpointExporter这个类偏偏还是 spring-boot-starter-websocket 提供的。所以必须要导入这个依赖。

@ServerEndpoint 注解中写上客户端连接的地址。

在类层次上,还得加上 @Component 注解才行。普通java web项目不用加。

这个方式开发的WebSocket服务器,每个连接加入都会为该连接新建一个服务器对象绑定。

这时,一个传统的WebSocket应用就开发完毕了。由于我是在SpringBoot下开发的,所以有一些调整。

启动应用后搞个普通的html页面直接本地打开就可以试验是否能够连接上了。

 

 

不过…我既然都导入了spring-boot-starter-websocket 依赖,自然最好还是用SprinBoot推荐的方法比较好。

这是使用SpringBoot的形式构建WebSocket应用程序:

 

这是核心配置类。实现WebSocketConfigurer接口实现它提供的注册方法。

这个方法就厉害了, 可以配置websocket入口,允许访问的域、注册Handler、定义拦截器等等等等。

@EnableWebSocket用于开启注解接收和发送消息

关于他这个拦截器,是非常重要的,最好还是设置一个。他可以在连接进入到Handler处理时进行一些操作。

比如从session中拿出用户登陆信息作为唯一标识符等等…

我把我的拦截器实现写成内部类了,反正也没多少东西。

这个配置注册的处理器和拦截器,都是只有一个的,无论你多少连接进来,都是用相同的对象处理。

那么就不好用传统的WebSocket开发那样用个集合类容器来存了。

用前置拦截设置进去的某些唯一标识作为key,session作为value用键值对映射类容器来存储连接是比较好的方案。

 

这是我实现的处理器,也是WebSocket开发的核心:

需要实现WebSocketHandler 接口,该接口提供了五个方法。

1、 afterConnectionEstablished():建立新的socket连接后回调的方法。

2、handleMessage():接收客户端发送的Socket。

3、handleTransportError():连接出错时,回调的方法。

4、afterConnectionClosed():连接关闭时,回调的方法。

5、supportsPartialMessages():这个是WebSocketHandler是否处理部分消息,没什么卵用 返回false就完事了。

至此,SpringBoot 与 WebSocket 已经集成完了。客户端仍然使用我上边那个HTML文件就行,访问地址改一下就完事了。

我的这个WebSocket项目整体源码地址:  Github

阅读全文
EA PLAYER &

历史记录 [ 注意:部分数据仅限于当前浏览器 ]清空

      00:00/00:00