高可用的服务注册中心：Eureka 集群搭建 ， 并使用Spring Security 为 Eureka 增加 Basic 安全认证机制
上一篇 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就是完全体了。
package com . skypyb . sc ;
import org . springframework . boot . SpringApplication ;
import org . springframework . boot . autoconfigure . SpringBootApplication ;
import org . springframework . cloud . netflix . eureka . server . EnableEurekaServer ;
@SpringBootApplication
@EnableEurekaServer //表示这个服务是一个 Eureka 服务注册中心
public class EurekaServerApplication {
public static void main ( String [ ] args ) {
SpringApplication application = new SpringApplication ( EurekaServerApplication . class ) ;
application . run ( args ) ;
}
}
此时可以在网页里通过 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的配置，下面就讲)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
spring :
profiles :
active : eureka1 # 启动时加上这个命令使用不同的配置 -- spring . profiles . active = xxx
security :
# 验证的用户名和密码
user :
name : user
password : 614
# Eureka Server 端配置
eureka :
client :
healthcheck :
enabled : true
service - url :
defaultZone : http : //user:614@localhost:8080/eureka/,http://user:614@localhost:8081/eureka/
-- -
spring :
profiles : eureka1
application :
name : sc - demo - microservice - eureka_1
server :
port : 8080
eureka :
instance :
hostname : eureka1
-- -
spring :
profiles : eureka2
application :
name : sc - demo - microservice - eureka_2
server :
port : 8081
eureka :
instance :
hostname : eureka2
在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的依赖后就会自动开启验证，不用配置。用户名和密码的设定就像上边文件一样，只需要这样就行。
spring :
security :
#验证的用户名和密码
user :
name : user
password : 614
配置完用户名和密码后，连接Eureka Server自然就需要用到这些用户名和密码。
本来连接Server的的URL: http://ip:port/eureka/
现在连接Server的的URL: http://username:password@ip:port/eureka/
就算是从网页查看状态，也需要输入用户名和密码了哦。
Client端最终配置文件如下(反正配置都长得差不多，我这就放其中一个服务的文件就行了):
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
server :
port : 8089
spring :
application :
name : sc - demo - microservice - movie # 这个名字会注册到 Eureka 里去
datasource :
driver - class - name : com . mysql . jdbc . Driver
url : jdbc : mysql : //192.168.8.113:3306/scdemo?serverTimezone=Asia/Shanghai
username : root
password : 614
# mybatis 实体类名
mybatis :
type - aliases - package : com . skypyb . sc . entity
configuration :
# 到下划线的表字段自动映射成驼峰命名法
map - underscore - to - camel - case : true
mapper - locations : classpath : mybatis / mapper / * . xml
# Actuato 配置
management :
endpoint :
# 暴露shutdown 功能
# shutdown :
# enabled : true
endpoints :
web :
exposure :
include : '*' # 暴露哪些端点
exclude : # 隐藏哪些端点
# Eureka client 端配置
eureka :
client :
service - url :
defaultZone : http : //user:614@localhost:8080/eureka/,http://user:614@localhost:8081/eureka/
instance :
prefer - ip - address : true # 将自己ip 注册到Eureka Server
这样，其实应该就完事了，但是
任何一次服务请求默认都需要CSRF 的token , 而我区区一个小Client，哪里来的这种东西。就是Eureka Server 自注册都会挂掉。
那么还是要让 Security 的CSRF拦截自动忽略掉注册Eureka的链接比较好。
在 Eureka Server 端增加这么一个配置类:
package com . skypyb . sc . config ;
import org . springframework . security . config . annotation . web . builders . HttpSecurity ;
import org . springframework . security . config . annotation . web . configuration . EnableWebSecurity ;
import org . springframework . security . config . annotation . web . configuration . WebSecurityConfigurerAdapter ;
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
@Override
protected void configure ( HttpSecurity http ) throws Exception {
http . csrf ( ) . ignoringAntMatchers ( "/eureka/**" ) ; //这个链接不使用csrf
super . configure ( http ) ;
}
}
这样子去除 /eureka/ 这个连接的 CSRF 效验。就都可以连接上了。
OK 整体 Eureka 注册中心都搭建完毕了。并且实现了集群高可用和安全策略，比较完善。
服务之间的调用在做一点点微小的改进：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package com . skypyb . sc . controller ;
import com . skypyb . sc . entity . User ;
import org . slf4j . Logger ;
import org . slf4j . LoggerFactory ;
import org . springframework . beans . factory . annotation . Autowired ;
import org . springframework . cloud . client . ServiceInstance ;
import org . springframework . cloud . client . discovery . DiscoveryClient ;
import org . springframework . web . bind . annotation . GetMapping ;
import org . springframework . web . bind . annotation . PathVariable ;
import org . springframework . web . bind . annotation . RequestMapping ;
import org . springframework . web . bind . annotation . RestController ;
import org . springframework . web . client . RestTemplate ;
import java . util . List ;
@RestController
@RequestMapping ( "/movie" )
public class MovieController {
private Logger logger = LoggerFactory . getLogger ( MovieController . class ) ;
@Autowired
private RestTemplate restTemplate ;
@Autowired
private DiscoveryClient discoveryClient ;
@GetMapping ( "/{id}" )
public User getUser ( @PathVariable Long id ) {
//获取 user 服务的信息
List <ServiceInstance> instances =
discoveryClient . getInstances ( "sc-demo-microservice-user" ) ;
String userUrl = instances . get ( 0 ) . getUri ( ) . toString ( ) ;
logger . info ( "access getUser method." ) ;
return restTemplate . getForObject ( userUrl + "/user/" + id , User . class ) ;
}
}
通过 DiscoveryClient 这个类，可以获取到对应服务的信息，这里我便是用 movie 服务获取到了user 服务的 url 来进行的调用。
当然，就算是这样，也不是那么的方便，关于feign声明式调用之后也会写篇文章的。
我的项目地址: github
阅读全文
Come on，搭一个Gradle多模块管理的 Spring Cloud Finchley 分布式微服务项目
Spring Cloud 是在 Spring Boot 基础上构建的，用于快速构建分布式系统的通用模式的工具集 。
别的理论、使用场景、历史之类的也不说了，直接切入主题。
这里，我就来架构一个简单 Spring Cloud 的应用。
既然要用，都9102年了，当然要与时俱进，我这里选择的是基于Spring Boot 2.0.x 的Spring Cloud Finchley。
开发工具: IDEA
JDK version: 1.8
具体的框架版本号: Spring Boot 2.0.5 RELEASE、Spring Cloud Finchley.SR3
项目管理工具: gradle ( 9102年了，maven这xml配置实在是够恶心的了
目前只是最原始的初版，使用RestTemplate简单的调用一下别的服务接口。 至于服务注册、发现、跟踪、容错、微服务网关、负载均衡之类的。之后也会慢慢写出文章的。
先把项目给搭起来。之后再要添加新的依赖增加新的功能就就简单许多了。
OK，进入正题。
先打开 IDEA 创建一个 Gradle 的Module。我创建的模块名字叫做 sc-demo-microservice
这个是根/父模块, 用于管理一个个的微服务。他可以在 ‘subprojects’ 这个代码块中配置所有子模块通用的配置。
我的build.gradle文件:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
group 'com.skypyb.sc'
version = '0.0.1-SNAPSHOT'
apply plugin : 'java'
sourceCompatibility = 1.8
targetCompatibility = 1.8
buildscript {
ext {
springBootVersion = '2.0.5.RELEASE'
springCloudVersion = 'Finchley.SR3'
}
repositories {
maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
jcenter ( )
mavenCentral ( )
}
dependencies { //用来打包
classpath ( "org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}" )
}
}
allprojects {
repositories {
maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
jcenter ( )
mavenCentral ( )
}
//指定编码格式
tasks . withType ( JavaCompile ) {
options . encoding = "UTF-8"
}
}
//设定子模块的通用配置
subprojects {
apply plugin : 'java'
apply plugin : 'idea'
//spring boot 插件
apply plugin : 'org.springframework.boot'
//Gradle插件，提供类似Maven的依赖关系管理功能
apply plugin : 'io.spring.dependency-management'
dependencies {
compile ( 'org.springframework.boot:spring-boot-starter-web' )
//Actuator提供服务监控与管理的功能,路径: /actuator/{端点}
compile ( 'org.springframework.boot:spring-boot-starter-actuator' )
compile ( 'org.mybatis.spring.boot:mybatis-spring-boot-starter:1.3.2' )
compile ( 'mysql:mysql-connector-java' )
testCompile ( 'org.springframework.boot:spring-boot-starter-test' )
}
dependencyManagement {
imports {
//spring bom帮助我们在不指定版本号的情况下声明依赖项。
mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
}
}
jar {
manifest . attributes provider : 'gradle'
}
}
可以看到我给所有的子模块添加了web、mysql、mybatis、Actuator的依赖。
Actuator这个东西是用于服务监控和管理的，这里不表，具体的可以看这个文章
gradle加载完毕后这个父模块就创建好了。gradle会自动给你生成一个src文件夹，删掉就行，也可以不删。反正父模块里边是不会放代码的。
然后就是建立子 module 了，子module 的创建是直接在父 module 上边右键 –> new Module 来进行创建的。当然，也是Gradle项目。
建好后将子 module 的 build.gradle文件里的东西全删掉，只留这个:
这个是用来添加该模块独有的依赖的。我这暂时为空。
我创建了一个用户微服务、一个电影微服务。里边都有具体的Dao、Service、Entity，这里就不贴了，太占位置。
我这里实现的RPC是通过Spring提供的RestTemplate，链接都是写死的，之后当然会优化。这里只是把项目运转起来。
两边的Controller层:
用户:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com . skypyb . sc . controller ;
import com . skypyb . sc . entity . User ;
import com . skypyb . sc . service . UserService ;
import org . slf4j . Logger ;
import org . slf4j . LoggerFactory ;
import org . springframework . beans . factory . annotation . Autowired ;
import org . springframework . web . bind . annotation . GetMapping ;
import org . springframework . web . bind . annotation . PathVariable ;
import org . springframework . web . bind . annotation . RequestMapping ;
import org . springframework . web . bind . annotation . RestController ;
@RestController
@RequestMapping ( "/user" )
public class UserController {
private Logger logger = LoggerFactory . getLogger ( UserController . class ) ;
@Autowired
private UserService userService ;
@GetMapping ( "/{id}" )
public User getUser ( @PathVariable Long id ) {
logger . info ( "access getUser method." ) ;
return userService . getUser ( id ) ;
}
}
电影:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package com . skypyb . sc . controller ;
import com . skypyb . sc . entity . User ;
import org . slf4j . Logger ;
import org . slf4j . LoggerFactory ;
import org . springframework . beans . factory . annotation . Autowired ;
import org . springframework . web . bind . annotation . GetMapping ;
import org . springframework . web . bind . annotation . PathVariable ;
import org . springframework . web . bind . annotation . RequestMapping ;
import org . springframework . web . bind . annotation . RestController ;
import org . springframework . web . client . RestTemplate ;
@RestController
@RequestMapping ( "/movie" )
public class MovieController {
private Logger logger = LoggerFactory . getLogger ( MovieController . class ) ;
@Autowired
private RestTemplate restTemplate ;
@GetMapping ( "/{id}" )
public User getUser ( @PathVariable Long id ) {
logger . info ( "access getUser method." ) ;
return restTemplate . getForObject ( "http://localhost:8088/user/" + id , User . class ) ;
}
}
这样子配好，启动服务时先启动 User 服务，然后启动 Movie 服务，然后通过浏览器输入 Movie 服务的接口获得数据。
最后结果是如愿以偿的得到了数据。而这份数据是 Movie 服务通过 rest 请求 User 服务所得来的。
他们的yml文件，因为长得差不多，所以就只贴这一个了
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
server :
port : 8089
spring :
application :
name : sc-demo-microservice-movie #这个名字会注册到 Eureka 里去
datasource :
driver-class-name : com.mysql.jdbc.Driver
url : jdbc :mysql ://192.168.8.113 :3306/scdemo?serverTimezone=Asia/Shanghai
username : root
password : 614
#mybatis实体类名
mybatis :
type-aliases-package : com.skypyb.sc.entity
configuration :
#到下划线的表字段自动映射成驼峰命名法
map-underscore-to-camel-case : true
mapper-locations : classpath :mybatis/mapper/*.xml
#Actuato 配置
management :
endpoint :
# 暴露shutdown功能
# shutdown:
# enabled: true
endpoints :
web :
exposure :
include : '*' #暴露哪些端点
exclude : #隐藏哪些端点
#Eureka client端配置
eureka :
client :
service-url :
defaultZone : http ://localhost :8080/eureka/
instance :
prefer-ip-address : true #将自己ip注册到Eureka Server
我的项目地址: github
里边sql语句、配置文件啥的都有。是个完整的项目。
结构如下:
下一篇文章是Eureka
阅读全文
从JMM的角度浅析volatile关键字功能及作用以及其基础原理
看下这样一段代码：
我在一个方法中建立了个死循环，循环的判断条件为一个boolean类型的成员变量。
然后在main线程中，创建了一个新的名为 “t1” 的线程，去执行这个方法。
等待一秒后，mian线程自身，将该成员变量的值改为false，试图使其不满足条件从而循环终止。
按照正常的逻辑来说，按照脑海中预演的情况来说，应该是没问题的。
可是执行后却没有得到想要的结果，控制台输出 “start” 后再无反应，程序一直没有终止，即 死循环没有退出。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package com . skypyb . test ;
public class VolatileDemo {
boolean flag = true ;
void run ( ) {
System . out . println ( "start" ) ;
while ( flag ) {
//这是个死循环
}
System . out . println ( "end" ) ;
}
public static void main ( String [ ] args ) {
VolatileDemo v = new VolatileDemo ( ) ;
new Thread ( v :: run , "t1" ) . start ( ) ;
//等一秒
try {
Thread . sleep ( 1000 ) ;
} catch ( InterruptedException e ) {
e . printStackTrace ( ) ;
}
v . flag = false ;
}
}
想要让程序正确执行的话，将定义语句 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 本来也有一篇文章要写的。想想还是算了，本来想写点加锁释放锁的原理、可重入性质和可见性和原理啥的。
不过我过了归纳的那一段时间了，现在想归纳总结一通怪麻烦的。反正这些知识脑子里都有，就不记录了。
阅读全文
传统@ServerEndpoint方式开发WebSocket应用和SpringBoot构建WebSocket应用程序。
WebSocket一次握手就可以使客户端和服务端建立长连接，并进行双向数据传输。
由于其双向传输特性，服务端可主动向客户端发送信息，实时性很高。
而与HTTP协议比起来WebSocket 协议每次数据传输的头信息都较小，节约带宽。
在获取实时数据这方面时，那是比ajax轮询方式高到不知道哪去了。
在SpringBoot架构下进行WebSocket服务开发的话,首先还是要导入这个
就算是使用Tomcat 7 的@ServerEndpoint进行 WebSocket开发,也得导。不然在SpringBoot环境下会有bug。
普通java web应用开发WebSocket就不需要了,@ServerEndpoint直接用就行。
compile ( 'org.springframework.boot:spring-boot-starter-websocket:2.0.4.RELEASE' )
maven仓库: spring-boot-starter-websocket
这是使用@ServerEndpoint 进行的传统WebSocket开发:
由于我是在SpringBoot环境,所以得先写个能扫描@ServerEndpoint的配置,不然在客户端连接的时候会一直连不上。不是在SpringBoot下开发的可以跳过这一环节。
ServerEndpointExporter这个类偏偏还是 spring-boot-starter-websocket 提供的。所以必须要导入这个依赖。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package com . skypyb . websocket ;
import org . springframework . context . annotation . Bean ;
import org . springframework . context . annotation . Configuration ;
import org . springframework . web . socket . server . standard . ServerEndpointExporter ;
@Configuration
public class WebSocketConfigOne {
/**
* 这个bean会自动注册使用了@ServerEndpoint注解声明的对象
* 没有的话会报404
*
* @return
*/
@Bean
public ServerEndpointExporter serverEndpointExporter ( ) {
return new ServerEndpointExporter ( ) ;
}
}
@ServerEndpoint 注解中写上客户端连接的地址。
在类层次上,还得加上 @Component 注解才行。普通java web项目不用加。
这个方式开发的WebSocket服务器，每个连接加入都会为该连接新建一个服务器对象绑定。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
package com . skypyb . websocket ;
import org . springframework . stereotype . Component ;
import javax . websocket . * ;
import javax . websocket . server . ServerEndpoint ;
import java . io . IOException ;
import java . util . concurrent . CopyOnWriteArraySet ;
/**
* @ServerEndpoint 该注解可以将类定义成一个WebSocket服务器端，
* @OnOpen 表示有浏览器链接过来的时候被调用
* @OnClose 表示浏览器发出关闭请求的时候被调用
* @OnMessage 表示浏览器发消息的时候被调用
* @OnError 表示报错了
*/
@ServerEndpoint ( "/ws/serverOne" )
@Component
public class WebSocketServerOne {
//concurrent包下线程安全的Set
private static final CopyOnWriteArraySet <WebSocketServerOne> SESSIONS = new CopyOnWriteArraySet <> ( ) ;
private Session session ;
@OnOpen
public void onOpen ( Session session ) {
this . session = session ;
SESSIONS . add ( this ) ;
System . out . println ( String . format ( "成功建立连接~ 当前总连接数为:%s" , SESSIONS . size ( ) ) ) ;
System . out . println ( this ) ;
}
@OnClose
public void onClose ( ) {
SESSIONS . remove ( this ) ;
System . out . println ( String . format ( "成功关闭连接~ 当前总连接数为:%s" , SESSIONS . size ( ) ) ) ;
}
@OnMessage
public void onMessage ( String message , Session session ) {
System . out . println ( message ) ;
}
@OnError
public void onError ( Session session , Throwable error ) {
System . out . println ( "发生错误" ) ;
error . printStackTrace ( ) ;
}
/**
* 指定发消息
*
* @param message
*/
public void sendMessage ( String message ) {
try {
this . session . getBasicRemote ( ) . sendText ( message ) ;
} catch ( IOException e ) {
e . printStackTrace ( ) ;
}
}
/**
* 群发消息
*
* @param message
*/
public static void fanoutMessage ( String message ) {
SESSIONS . forEach ( ws -> ws . sendMessage ( message ) ) ;
}
}
这时，一个传统的WebSocket应用就开发完毕了。由于我是在SpringBoot下开发的，所以有一些调整。
启动应用后搞个普通的html页面直接本地打开就可以试验是否能够连接上了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
<!DOCTYPE html>
<html lang = "en" >
<head>
<meta charset = "UTF-8" >
<title> webSocket </title>
<style type ="text/css">
</style>
</head>
<body>
<h1> WebSocket Demo. </h1>
<h1> WebSocket Demo.. </h1>
<h1> WebSocket Demo... </h1>
<input type = "button" onclick = "websocket.send('666666666')" value = "点我发消息" />
</body>
<script type = "application/javascript" >
var websocket = {
send : function ( str ) {
}
} ;
window . onload = function ( ) {
if ( ! 'WebSocket' in window ) return ;
webSocketInit ( ) ;
} ;
function webSocketInit ( ) {
websocket = new WebSocket ( "ws://127.0.0.1:8080/ws/serverOne" ) ;
//成功建立连接
websocket . onopen = function ( ) {
websocket . send ( "成功连接到服务器" ) ;
} ;
//接收到消息
websocket . onmessage = function ( event ) {
console . log ( event . data )
} ;
//连接发生错误
websocket . onerror = function ( ) {
alert ( "WebSocket连接发生错误" ) ;
} ;
//连接关闭
websocket . onclose = function ( ) {
alert ( "WebSocket连接关闭" ) ;
} ;
//监听窗口关闭事件，当窗口关闭时，主动关闭websocket连接
window . onbeforeunload = function ( ) {
websocket . close ( )
} ;
}
</script>
</html>
不过…我既然都导入了spring-boot-starter-websocket 依赖，自然最好还是用SprinBoot推荐的方法比较好。
这是使用SpringBoot的形式构建WebSocket应用程序:
这是核心配置类。实现WebSocketConfigurer
这个方法就厉害了, 可以配置websocket入口，允许访问的域、注册Handler、定义拦截器等等等等。
@EnableWebSocket用于开启注解接收和发送消息
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
package com . skypyb . springboot_websocket ;
import org . springframework . context . annotation . Configuration ;
import org . springframework . http . server . ServerHttpRequest ;
import org . springframework . http . server . ServerHttpResponse ;
import org . springframework . http . server . ServletServerHttpRequest ;
import org . springframework . web . socket . WebSocketHandler ;
import org . springframework . web . socket . config . annotation . EnableWebSocket ;
import org . springframework . web . socket . config . annotation . WebSocketConfigurer ;
import org . springframework . web . socket . config . annotation . WebSocketHandlerRegistry ;
import org . springframework . web . socket . server . HandshakeInterceptor ;
import java . util . Map ;
@Configuration
@EnableWebSocket
public class WebSocketConfigTwo implements WebSocketConfigurer {
@Override
public void registerWebSocketHandlers ( WebSocketHandlerRegistry registry ) {
registry . addHandler ( new MyWebSocketHandler ( ) , "/ws/serverTwo" ) //设置连接路径和处理
. setAllowedOrigins ( "*" )
. addInterceptors ( new MyWebSocketInterceptor ( ) ) ; //设置拦截器
}
/**
* 自定义拦截器拦截WebSocket请求
*/
class MyWebSocketInterceptor implements HandshakeInterceptor {
//前置拦截一般用来注册用户信息，绑定 WebSocketSession
@Override
public boolean beforeHandshake ( ServerHttpRequest request , ServerHttpResponse response ,
WebSocketHandler wsHandler , Map < String , Object > attributes ) throws Exception {
System . out . println ( "前置拦截~~" ) ;
if ( ! ( request instanceof ServletServerHttpRequest ) ) return true ;
// HttpServletRequest servletRequest = ((ServletServerHttpRequest) request).getServletRequest();
// String userName = (String) servletRequest.getSession().getAttribute("userName");
String userName = "Koishipyb" ;
attributes . put ( "userName" , userName ) ;
return true ;
}
@Override
public void afterHandshake ( ServerHttpRequest request , ServerHttpResponse response ,
WebSocketHandler wsHandler , Exception exception ) {
System . out . println ( "后置拦截~~" ) ;
}
}
}
关于他这个拦截器,是非常重要的，最好还是设置一个。他可以在连接进入到Handler处理时进行一些操作。
比如从session中拿出用户登陆信息作为唯一标识符等等…
我把我的拦截器实现写成内部类了，反正也没多少东西。
这个配置注册的处理器和拦截器，都是只有一个的，无论你多少连接进来，都是用相同的对象处理。
那么就不好用传统的WebSocket开发那样用个集合类容器来存了。
用前置拦截设置进去的某些唯一标识作为key，session作为value用键值对映射类容器来存储连接是比较好的方案。
这是我实现的处理器,也是WebSocket开发的核心:
需要实现WebSocketHandler 接口,该接口提供了五个方法。
1、 afterConnectionEstablished():建立新的socket连接后回调的方法。
2、handleMessage():接收客户端发送的Socket。
3、handleTransportError():连接出错时，回调的方法。
4、afterConnectionClosed():连接关闭时，回调的方法。
5、supportsPartialMessages():这个是WebSocketHandler是否处理部分消息，没什么卵用 返回false就完事了。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
package com . skypyb . springboot_websocket ;
import org . springframework . web . socket . * ;
import java . io . IOException ;
import java . util . Map ;
import java . util . concurrent . ConcurrentHashMap ;
public class MyWebSocketHandler implements WebSocketHandler {
private static final Map < String , WebSocketSession > SESSIONS = new ConcurrentHashMap <> ( ) ;
@Override
public void afterConnectionEstablished ( WebSocketSession session ) throws Exception {
String userName = session . getAttributes ( ) . get ( "userName" ) . toString ( ) ;
SESSIONS . put ( userName , session ) ;
System . out . println ( String . format ( "成功建立连接~ userName: %s" , userName ) ) ;
}
@Override
public void handleMessage ( WebSocketSession session , WebSocketMessage < ? > message ) throws Exception {
String msg = message . getPayload ( ) . toString ( ) ;
System . out . println ( msg ) ;
}
@Override
public void handleTransportError ( WebSocketSession session , Throwable exception ) throws Exception {
System . out . println ( "连接出错" ) ;
if ( session . isOpen ( ) ) {
session . close ( ) ;
}
}
@Override
public void afterConnectionClosed ( WebSocketSession session , CloseStatus closeStatus ) throws Exception {
System . out . println ( "连接已关闭,status:" + closeStatus ) ;
}
@Override
public boolean supportsPartialMessages ( ) {
return false ;
}
/**
* 指定发消息
*
* @param message
*/
public static void sendMessage ( String userName , String message ) {
WebSocketSession webSocketSession = SESSIONS . get ( userName ) ;
if ( webSocketSession == null || ! webSocketSession . isOpen ( ) ) return ;
try {
webSocketSession . sendMessage ( new TextMessage ( message ) ) ;
} catch ( IOException e ) {
e . printStackTrace ( ) ;
}
}
/**
* 群发消息
*
* @param message
*/
public static void fanoutMessage ( String message ) {
SESSIONS . keySet ( ) . forEach ( us -> sendMessage ( us , message ) ) ;
}
}
至此，SpringBoot 与 WebSocket 已经集成完了。客户端仍然使用我上边那个HTML文件就行，访问地址改一下就完事了。
我的这个WebSocket项目整体源码地址: Github
阅读全文
关于SpringDataJPA使用CriteriaBuilder生成WHERE子句(Predicate对象)时如何使用自定义值代替Expression参数
今天使用Specification 接口创建动态SQL时遇到了个坑。
关于SpringDataJPA如何优雅的定制高效率SQL,即使用Specification 接口创建SQL表示并执行 可以看: 这个
主要就是用CriteriaBuilder 创建 locate 语句遇到个问题。以此可以衍生到 CriteriaBuilder 所有用得上Expression入参的方法上。
关于Mysql的locate方法: LOCATE(substr,str) :返回子串 substr 在字符串 str 中第一次出现的位置。如果子串 substr 在 str 中不存在，返回值为 0：
CriteriaBuilder 在创建 locate 子句时,第一个参数是 LOCATE(substr,str) 中的 str,第二个才是 substr。完全颠倒了过来。很不符合逻辑。
下面是他的几个创建locate方法:
Expression <Integer> locate ( Expression <String> x , Expression <String> pattern ) ;
Expression <Integer> locate ( Expression <String> x , String pattern ) ;
Expression这玩意，一般是通过Root类的get方法来指定一个表字段的。
根据他提供的方法 我无法做到在一个自定义值中查找table字段是否包含在内,只能判断table字段是否包含我的自定义值。
因为他只有第二个参数接受一个String变量, 即表示传入的String参数是否是第一个参数x的子串(x表示一个表字段,通过root.get()得出)。
而我的需求则为需要在我提供的字符串中寻找一个表字段是否为我提供字符串的子串。
要是想以他提供的方法来实现我的需求,第一个参数是我需要自己设定自定义String值的。而我又无法设定，这就有点恶心了。
经过我不懈的查询。终于，什么方案都没查出来。 那没办法了，只能去看一下源码看看有没有什么收获。
我就好奇他这入参String到底经厉了一些什么, 翻了一下,结果还真有。
进入到 locate(Expression<String> x, String pattern) 方法的底层实现。
可以看到 他实际上是new 了一个LocateFunction, 传入了String入参pattern
@Override
public Expression <Integer> locate ( Expression <String> string , String pattern ) {
return new LocateFunction ( this , pattern , string ) ;
}
然后，看一下所使用到的LocateFunction的构造方法:
public LocateFunction ( CriteriaBuilderImpl criteriaBuilder , String pattern , Expression <String> string ) {
this (
criteriaBuilder ,
new LiteralExpression <String> ( criteriaBuilder , pattern ) ,
string ,
null
) ;
}
嗨，有发现了,他实例化了一个 LiteralExpression 类,传入了 CriteriaBuilder 的一个实现和String类型的pattern参数。
而LiteralExpression 类又实现了Expression接口。
我来一个如法炮制，创建一个LiteralExpression 对象,放入自己想要的参数: new LiteralExpression<>(cb, title) 。
传的cb对象是Specification 接口的toSpecification 方法提供的CriteriaBuilder 对象。
然后使用这个locate方法: 将我初始化的LiteralExpression作为第一个参数,root.get()获取的Expression作为第二个参数。
Expression <Integer> locate ( Expression <String> x , Expression <String> pattern ) ;
然后debug断点调试一下。 emmmm 然后就报错了。
很疑惑，后面又试了一下别的东西，塞不进去，干脆给第一个参数传了个null，神tm就可以了。至于为什么,我也不甚了解。
贴上这段转换为sql语句后与我想象吻合的的 Predicate 。
//(type = 1 AND locate(text,titleExpr)>0)
LiteralExpression <String> titleExpr = new LiteralExpression <> ( null , title ) ; //titleExpr==自定义的title参数变量
Predicate titleIsMatch = cb . gt ( cb . locate ( titleExpr , root . get ( "text" ) ) , 0 ) ;
Predicate titlePredicate = cb . and ( cb . equal ( root . get ( "type" ) , 1 ) , titleIsMatch ) ;
阅读全文
1
2
…
27
