Springcloud Eureka和Feign

作者: 過眼云烟 | 来源:发表于2019-06-10 20:31 被阅读0次

是SpringBoot与Spring Cloud版本的对照表，

Spring Boot Spring Cloud
1.2.x             Angel版本
1.3.x             Brixton版本
1.4.x             Camden版本
1.5.x             Dalston版本、Edgware版本
2.0.x             Finchley版本

服务发现组件 Eureka --服务端开发

Eureka通过心跳检查、客户端缓存等机制，确保了系统的高可用性、灵活性和可伸缩性。
（1）引入依赖父工程pom.xml定义SpringCloud版本

<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring‐cloud‐dependencies</artifactId>
<version>Finchley.M9</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>

tensquare_eureka模块pom.xml引入eureka-server

<dependencies>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring‐cloud‐starter‐netflix‐eureka‐
server</artifactId>
</dependency>
</dependencies>

（2）添加application.yml

server:
port: 6868 #服务端口
eureka:
client:
registerWithEureka: false #是否将自己注册到Eureka服务中，本身就是所有无需
注册
fetchRegistry: false #是否从Eureka中获取注册信息
serviceUrl: #Eureka客户端与Eureka服务端进行交互的地址
defaultZone: http://127.0.0.1:${server.port}/eureka/

（3）编写启动类创建包com.tensquare.eureka ，包下建立类

@SpringBootApplication
@EnableEurekaServer  //开启EurekaServer
public class EurekaServer {
public static void main(String[] args) {
SpringApplication.run(EurekaServer.class, args);
}
}

（4）启动运行启动类，然后在浏览器地址栏输入 http://localhost:6868/ 运行效果如下：
主界面中system status为系统信息 General Info为一般信息 Instances currentlyregistered with Eureka为注册到的所有微服务列表

服务注册

（1）将其他微服务模块添加依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring‐cloud‐starter‐netflix‐eureka‐
client</artifactId>
</dependency>

（2）修改每个微服务的application.yml，添加注册eureka服务的配置

eureka:
client:
service‐url:
defaultZone: http://localhost:6868/eureka
instance:
prefer‐ip‐address: true  //开启跨域访问

（3）修改每个服务类的启动类，添加注解

@EnableEurekaClient

（4）启动测试：将每个微服务启动起来，会发现eureka的注册列表中可以看到这些微服
务了

保护模式--会爆红

Eureka Server在运行期间，会统计心跳失败的比例在15分钟之内是否低于85%，如果出
现低于的情况（在单机调试的时候很容易满足，实际在生产环境上通常是由于网络不稳
定导致），Eureka Server会将当前的实例注册信息保护起来，同时提示这个警告。

Feign实现服务间的调用

（1）在tensquare_qa模块添加依赖

<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring‐cloud‐starter‐openfeign</artifactId>
</dependency>

（2）修改tensquare_qa模块的启动类，添加注解

@EnableDiscoveryClient
@EnableFeignClients

（3）在tensquare_qa模块创建 com.tensquare.qa.client包，包下创建接口 (需要调用的模块下，创立client包，创立接口)

@FeignClient("tensquare‐base")
public interface LabelClient {
@RequestMapping(value="/label/{id}", method = RequestMethod.GET)
public Result findById(@PathVariable("id") String id);
}

@FeignClient注解用于指定从哪个服务中调用功能，注意里面的名称与被调用的服务
名保持一致，并且不能包含下划线。
@RequestMapping注解用于对被调用的微服务进行地址映射。注意 @PathVariable注
解一定要指定参数名称，否则出错
（4）修改tensquare_qa模块的 ProblemController

@Autowired
private LabelClient labelClient;
@RequestMapping(value = "/label/{labelid}")
public Result findLabelById(@PathVariable String labelid){
Result result = labelClient.findById(labelid);
return result;
}

（6）测试：http://localhost:9003/problem/label/1 能看到标签的信息

交友微服务开发 --案列

交友微服务本身的功能:
（1）当用户登陆后在推荐好友列表中点击“心”，表示喜欢此人，在数据库tb_friend表中
插入一条数据，islike 为0
（2）当你点击了喜欢过的人，也喜欢了你 , 表示互粉成功！也向tb_friend表中插入一条
数据，islike为1 ，并且将你喜欢她的数据islike也修改为1
（3）当你点击了不喜欢某人（点击了叉），向tb_nofriend添加记录.
（4）当两个人互粉后，其中一人不喜欢对方了，删除好友表中的记录，向非好友表中添
加记录
什么场景下使用springCloud呢？
我们来看用户表，有两列： fanscount 表示粉丝数，followcount表示关注数
（1）当用户点击了喜欢：
比如小宝关注了楚楚，小宝的followcount（关注数）加1 ，楚楚的fanscount （粉丝
数）加1
（2）当用户删除了好友：
比如楚楚删除了好友小宝，小宝的fanscount （粉丝数）减1 ，楚楚的followcount（关
注数）减1

交友微服务-添加与删除好友

（1）创建工程tensquare_friend，pom.xml引入依赖

<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐data‐jpa</artifactId>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql‐connector‐java</artifactId>
</dependency>
<dependency>
<groupId>com.tensquare</groupId>
<artifactId>tensquare_common</artifactId>
<version>1.0‐SNAPSHOT</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring‐boot‐starter‐data‐redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring‐cloud‐starter‐netflix‐eureka‐
client</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring‐cloud‐starter‐openfeign</artifactId>
</dependency>
</dependencies>

（2）创建application.yml

server:
port: 9010
spring:
application:
name: tensquare‐friend #指定服务名
datasource:
driverClassName: com.mysql.jdbc.Driver
url: jdbc:mysql://192.168.184.134:3306/tensquare_friend?
characterEncoding=utf‐8
username: root
password: 123456
jpa:
database: MySQL
show‐sql: true
jwt:
config:
key: itcast
eureka:
client:
service‐url:
defaultZone: http://localhost:6868/eureka
instance:
prefer‐ip‐address: true

（3）编写启动类

@SpringBootApplication
@EnableEurekaClient
@EnableDiscoveryClient
@EnableFeignClients
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Bean
public IdWorker idWorkker(){
return new IdWorker(1, 1);
}
@Bean
public JwtUtil jwtUtil(){
return new util.JwtUtil();
}
}

（4）创建JwtFilter（参见User工程）
（5）创建ApplicationConfig（参见User工程）

添加好友

（1）创建实体类

@Entity
@Table(name="tb_friend")
@IdClass(Friend.class)
public class Friend implements Serializable {
@Id
private String userid;
@Id
private String friendid;

（2）新建dao包，创建FriendDao接口

/**
* 交友数据访问层
*/
public interface FriendDao extends JpaRepository<Friend,String> {
/**
* 根据用户ID与被关注用户ID查询记录个数
* @param userid
* @param friendid
* @return
*/
@Query("select count(f) from Friend f where f.userid=?1 and
f.friendid=?2")
public int selectCount(String userid,String friendid);
/**
* 更新为互相喜欢
* @param userid
* @param friendid
*/
@Modifying
@Query("update Friend f set f.islike=?3 where f.userid=?1 and
f.friendid=?2")
public void updateLike(String userid,String friendid,String islike);
}

（3）创建业务逻辑类
创建com.tensquare.friend.service包，包下建立类FriendService

@Service
public class FriendService {
@Autowired
private FriendDao friendDao;
@Transactional
public int addFriend(String userid,String friendid){
//判断如果用户已经添加了这个好友，则不进行任何操作,返回0
if(friendDao.selectCount(userid, friendid)>0){
return 0;
}
//向喜欢表中添加记录
Friend friend=new Friend();
friend.setUserid(userid);
friend.setFriendid(friendid);
friend.setIslike("0");
friendDao.save(friend);
//判断对方是否喜欢你，如果喜欢，将islike设置为1
if(friendDao.selectCount( friendid,userid)>0){
friendDao.updateLike(userid,friendid,"1");
friendDao.updateLike(friendid,userid,"1");
}
return 1;
}
}

（3）控制器类
创建包com.tensquare.friend.controller，包下创建FriendController

@RestController
@RequestMapping("/friend")
public class FriendController {
@Autowired
private FriendService friendService;
@Autowired
private HttpServletRequest request;
/**
* 添加好友
* @param friendid 对方用户ID
* @param type 1：喜欢 0：不喜欢
* @return
*/
@RequestMapping(value="/like/{friendid}/{type}",method=
RequestMethod.PUT)
public Result addFriend(@PathVariable String friendid , @PathVariable
String type){
Claims claims=(Claims)request.getAttribute("user_claims");
if(claims==null){
return new Result(false, StatusCode.ACCESSERROR,"无权访问");
}
//如果是喜欢
if(type.equals("1")){
if(friendService.addFriend(claims.getId(),friendid)==0){
return new Result(false, StatusCode.REPERROR,"已经添加此好
友");
}
}else{
//不喜欢
}
return new Result(true, StatusCode.OK, "操作成功");
}
}

（4）测试：
启动用户微服务，登陆用户获取token
启动交友微服务，通过postMan测试 http://localhost:9010/friend/like/1/1,添加头信息 Authorization 内容为Bearer 加上获取的token

添加非好友

需求：当用户点击不喜欢某人，将对方的ID记录不喜欢列表中
（1）构建实体类

@Entity
@Table(name="tb_nofriend")
@IdClass(NoFriend.class)
public class NoFriend implements Serializable {
@Id
private String userid;
@Id
private String friendid;
public String getUserid() {
return userid;
}
public void setUserid(String userid) {
this.userid = userid;
}
public String getFriendid() {
return friendid;
}
public void setFriendid(String friendid) {
this.friendid = friendid;
}
}

（2）创建数据访问接口

/**
* 不喜欢列表数据访问层
*/
public interface NoFriendDao extends JpaRepository<NoFriend,String> {
}

（3）修改业务逻辑类FriendService

@Autowired
private NoFriendDao noFriendDao;
/**
* 向不喜欢列表中添加记录
* @param userid
* @param friendid
*/
public void addNoFriend(String userid,String friendid){
NoFriend noFriend=new NoFriend();
noFriend.setUserid(userid);
noFriend.setFriendid(friendid);
noFriendDao.save(noFriend);
}

（2）修改FriendController的addFriend方法

/**
* 添加好友
* @param friendid 对方用户ID
* @param type 1：喜欢 0：不喜欢
* @return
*/
@RequestMapping(value="/like/{friendid}/{type}",method=
RequestMethod.PUT)
public Result addFriend(@PathVariable String friendid , @PathVariable
String type){
Claims claims=(Claims)request.getAttribute("user_claims");
if(claims==null){
return new Result(false, StatusCode.ACCESSERROR,"无权访问");
}
//如果是喜欢
if(type.equals("1")){
if(friendService.addFriend(claims.getId(),friendid)==0){
return new Result(false, StatusCode.REPERROR,"已经添加此好
友");
}
}else{
//不喜欢
friendService.addNoFriend(claims.getId(),friendid);//向不喜欢
列表中添加记录
}
return new Result(true, StatusCode.OK, "操作成功");
}

删除好友

（1）FriendDao新增方法定义

/**
* 删除喜欢
* @param userid
* @param friendid
*/
@Modifying
@Query("delete from Friend f where f.userid=?1 and f.friendid=?2")
public void deleteFriend(String userid,String friendid);

（2）FriendService新增方法

/**
* 删除好友
* @param userid
* @param friendid
*/
@Transactional
public void deleteFriend(String userid,String friendid){
friendDao.deleteFriend(userid,friendid);
friendDao.updateLike(friendid,userid,"0");
addNoFriend(userid,friendid);//向不喜欢表中添加记录
}

（3）FriendController新增方法

/**
* 删除好友
* @param friendid
* @return
*/
@RequestMapping(value="/{friendid}",method=RequestMethod.DELETE)
public Result remove(@PathVariable String friendid){
Claims claims=(Claims)request.getAttribute("user_claims");
if(claims==null){
return new Result(false, StatusCode.ACCESSERROR,"无权访问");
}
friendService.deleteFriend(claims.getId(), friendid);
return new Result(true, StatusCode.OK, "删除成功");
}

用户微服务-粉丝数与关注数的变更

（1）修改tensquare_user工程的UserDao，增加方法定义

/**
* 更新粉丝数
* @param userid 用户ID
* @param x 粉丝数
*/
@Modifying
@Query("update User u set u.fanscount=u.fanscount+?2 where u.id=?1")
public void incFanscount(String userid,int x);

（2）UserService增加方法

/**
* 更新粉丝数
* @param x
*/
@Transactional
public void incFanscount(String userid,int x){
userDao.incFanscount(userid,x);
}

（3）UserController增加方法

/**
* 增加粉丝数
* @param userid
* @param x
*/
@RequestMapping(value="/incfans/{userid}/{x}",method=
RequestMethod.POST)
public void incFanscount(@PathVariable String userid,@PathVariable
int x){
userService.incFanscount(userid,x);
}

变更关注数

（1）修改tensquare_user工程的UserDao，增加方法定义

/**
* 更新关注数
* @param userid 用户ID
* @param x 粉丝数
*/
@Modifying
@Query("update User u set u.followcount=u.followcount+?2 where
u.id=?1")
public void incFollowcount(String userid,int x);

（2）UserService增加方法

/**
* 更新关注数
* @param x
*/
@Transactional
public void incFollowcount(String userid,int x){
userDao.incFollowcount(userid,x);
}

（3）UserController增加方法

/**
* 增加关注数
* @param userid
* @param x
*/
@RequestMapping(value="/incfollow/{userid}/{x}",method=
RequestMethod.POST)
public void incFollowcount(@PathVariable String userid,@PathVariable
int x){
userService.incFollowcount(userid,x);
}

调用用户微服务

（1）在tensquare_friend模块创建 com.tensquare.friend.client包，包下创建接口

/**
* 用户客户端
*/
@FeignClient("tensquare‐user")
public interface UserClient {
/**
* 增加粉丝数
* @param userid
* @param x
*/
@RequestMapping(value="/user/incfans/{userid}/{x}",method=
RequestMethod.POST)
public void incFanscount(@PathVariable("userid") String userid,
@PathVariable("x") int x);
/**
* 增加关注数
* @param userid
* @param x
*/
@RequestMapping(value="/user/incfollow/{userid}/{x}",method=
RequestMethod.POST)
public void incFollowcount(@PathVariable("userid") String
userid,@PathVariable("x") int x);
}

（2）修改FriendService ，注入UserClient

@Autowired
private UserClient userClient;

修改addFriend方法,增加对userClient方法的调用

userClient.incFollowcount(userid,1);//增加自己的关注数
userClient.incFanscount(friendid,1);//增加对方的粉丝数

删除好友更新用户数据

修改FriendService的deleteFriend方法 ,增加调用

userClient.incFollowcount(userid,‐1);//减少自己的关注数
userClient.incFanscount(friendid,‐1);//减少对方的粉丝数