引言
本文中的功能是以7.1快速开发一个微服务为基础, 如果不了解，请先阅读那一篇博客
本文介绍了F1平台的一些常用功能：使用统一权限、使用缓存、使用统一配置、获取常用配置参数、微服务自定义配置参数、使用模型服务对模型数据增删改查、使用工作流服务、BD控件事件定制、Bp控件服务定制、异构数据库支持、多数据源支持、即时推送、jms消息、kafka消息、自动装配组件开发、interface组件开发、服务调用、服务事件扩展
使用统一权限
F1平台的各模块都是以微服务的形式存在的，都需要有权限认证才能访问，我们用一个名叫authServer的微服务作为授权服务器，各微服务都通过授权服务器进行统一权限认证，方便进行权限的管理。给当前微服务加权限的方法如下。
在当前的微服务中依赖f1-starter-auth（如果已经引入了f1-starter,就会间接引入f1-starter-auth），如果没有授权的请求来访问，就会被拒绝。
application.properties中加入权限服务器参数：
###########################oauth服务器相关配置#####################
# 认证服务器凭证
security.sessions:never
security.oauth2.client.client-id: client-id
security.oauth2.client.client-secret: client-secret
security.oauth2.client.access-token-uri: http://IP地址/uaa/oauth/token
security.oauth2.client.user-authorization-uri: http://IP地址/uaa/oauth/authorize
security.oauth2.resource.user-info-uri: http://IP地址/uaa/user# 断路器配置共享security上下文
hystrix.shareSecurityContext: true
###########################swagger兼容授权配置#####################
security.userOauth.type=oauth2
security.userOauth.tokenName=access_token
security.userOauth.scope.code=write
security.userOauth.scope.desc=write
app.key=f1swagger
app.name=F1平台微服务请求API
app.desc=更多的下载资源和信息请查看：http://192.168.1.173/f1-platform/f1-microService/
app.version=3.0.0
app.termsOfServiceUrl=http://192.168.1.173/f1-platform/f1-microService/
app.contact.name=平台组
app.contact.url=http://http://blog.csdn.net/zhbr_f1
app.contact.email=**
app.license=The F1 Platform, Version 3.0
app.licenseUrl=http://http://blog.csdn.net/zhbr_f1
加入redis的配置，因为权限认证信息要缓存在redis中
####################### REDIS (RedisProperties)
# Redis数据库索引（默认为0
spring.redis.database=0
# Redis连接密码
spring.redis.password=****
# Redis数据库服务地址
spring.redis.host=192.168.***.***
# Redis服务器连接端口
spring.redis.port=6379
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0在启动类上加上标注：
@EnableOAuth2Sso这样就只有授权的请求可以访问当前微服务了
在刚才那个url后边加上权限相关的参数（用户名密码认证通过后返回的，真正系统中是自动加上的，这里加到url后边只是为了演示）就可以访问了
使用缓存
在平时的业务操作中，有一些请求会频繁访问数据库取一些重复的值，或是请求的是一些比较耗时的资源，这时我们都可以把请求的结果加到缓存中，来提交访问的效率。平台的缓存主要是用redis来实现的。使用方法如下。
redis配置
依赖f1-starter会级联依赖f1-starter-cache
然后在application.properties中加入redis的配置
# REDIS (RedisProperties)
# Redis数据库索引（默认为0
spring.redis.database=0
# Redis连接密码
spring.redis.password=sys
# Redis数据库服务地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0
缓存使用
下边在service方法上加一个用name作为key的缓存
@Cacheable(value="queryDb", key="#name")
public String queryDb(String name) {
//查询数据库示例
List<?> ls = genericDao.getDataWithSQL("select count(1) from us_sys.tb_sys_person");
int ranNum = new Random().nextInt(100);
return ls.get(0).toString()+"人 "+ranNum+name;
}
请求时的name不变，返回的值就还是原来的值，注意中间的随机数不会变，因为是从缓存中取的，方法没有被执行
更新
通常都是查询的时候从缓存中查，当这个值更新到数据库中时就更新这条缓存（从缓存中把这条数据清除）
@Override
@CacheEvict(value="queryDb", key="#name")
public void update(String name) {
System.out.println("更新数据时，更新缓存");
}
这样就可以用@CacheEvict把对应的记录在更新时从缓存中清除
使用统一配置
平台的各个微服务所需要的配置参数有些是相同的，为了避免在每个微服务中都配置相同的参数，我们把这些共享的参数配置在configServer配置服务器中，使用方法如下。
1.添加依赖
<!-- 需要配置服务器，依赖此项可以读到配置服务器中相应配置文件 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-config</artifactId>
</dependency>
<!-- 监控：配置文件实时可见 -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<!-- kafka消息总线 -->
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-bus-kafka</artifactId>
</dependency>2.配置参数
# 能否发现配置
spring.cloud.config.discovery.enabled=true
# 配置中心服务id
spring.cloud.config.discovery.serviceId=f1-configserver
# 场景
spring.cloud.config.profile=dev
# 分支
spring.cloud.config.label=master
# 配置中心地址
spring.cloud.config.uri=http://localhost:7001/
# 是否使用本地配置文件（当此配置项为native时，将使用本地配置文件）
# spring.profiles.active=native
# kafka,服务器上搭建的kafka（依赖kafka服务器）
spring.cloud.stream.kafka.binder.zk-nodes=[kafkaIp]:2181
spring.cloud.stream.kafka.binder.brokers=[kafkaIp]:9092
至此，我们的微服务已经使用了配置服务器提供的配置文件，当我们将git上的配置文件修改了该如何通知所有服务刷新呢？通过发送post请求：http://ip:配置服务器端口/bus/refresh进行配置信息的刷新。
3. 读取配置参数值
在配置服务器指定的配置文件中加一条参数
configServer.testValue=aaaaaaaallllll下边可以用@Value把值注入到变量
/** 获取配置服务器中的参数 */
@Value("${configServer.testValue}")
private String testConfigValue;
@Override
@Cacheable(value="queryDb", key="#name")
public String queryDb(String name) {
//查询数据库示例
List<?> ls = genericDao.getDataWithSQL("select count(1) from us_sys.tb_sys_person");
int ranNum = new Random().nextInt(100);
return ls.get(0).toString()+"人 "+ranNum+name+testConfigValue;
}
获取常用配置参数
有时候我们在开发时要获取一些平台的配置参数（配置在application.properties中以platform.config开头的），比如获取当前连接的数据库的类型，可以用下边的方式去获取。
例如：
String dbtype = Platform.INSTANCE.getString("dbtype"); 就可以得到数据库类型
微服务自定义配置参数
有时候我们需要配置一些自己的参数，方法如下。
在application.properties配置文件中加一条名叫“self.test.arg1”的参数
##自定义的参数
self.test.arg1=111111在java代码中读取 有两种方式，如下所示
@Value("${self.test.arg1}") //第一种方式，用@Value
private String selfArgs;
private Environment environment;
public String getSelfArgs() {
return selfArgs;
}
public String getPlatformSelfArgs() {
return Platform.getPlatform().getString("self.test.", "arg1"); //第二种方式，用Platform取值
}使用模型服务
有时我们需要在后台对模型数据进行增删改查的操作，这时我们就要调用平台提供的模型服务接口，这里以singleDBClient为例对一个模型数据进行操作，具体如下。
增加依赖：
<dependency>
<groupId>com.joinbright.f1</groupId>
<artifactId>f1-interface-model</artifactId>
</dependency>在启动类中加标注
@EnableFeignClients("com.jb.*.client")
@ComponentScan调用SingleDBClient进行增删改查
@Autowired
private SingleBDClient singleBDClient;
@Override
public void operModelData() {
String clsID = "3AC9D405-B3A7-488B-A662-01ED06D73B60";
String appID = "3883C374-E197-4216-83C6-ACE77EB7A0E2";
//新增
String newGUID = GUID.newGUID();
String createData = "{\"GUID\":\""+newGUID+"\",\"BDZMC\":\"变电站修改测试1\",\"TYRQ\":\"2012-09-21 21:23:33\"}";
String createReturn = singleBDClient.cmdCreateBD(createData, appID, clsID);
System.out.println(createReturn);
//查询
String getReturn = singleBDClient.cmdGetBD(newGUID, appID, clsID);
System.out.println(getReturn);
//修改
createData = "{\"GUID\":\""+newGUID+"\",\"BDZMC\":\"变电站修改测试1修改\",\"TYRQ\":\""+DateUtil.formatLongtime(new Date())+"\"}";
String saveReturn = singleBDClient.cmdSaveBD(createData, appID, clsID);
System.out.println(saveReturn);
//删除
String delReturn = singleBDClient.cmdDeleteBD(newGUID, appID, clsID);
System.out.println(delReturn);
}使用工作流服务
有时候我们需要在后台对流程的数据进行操作，发起流程，下一步，结束流程，删除流程，下边对这些操作进行演示。
在pom中加依赖
<dependency>
<groupId>com.joinbright.f1</groupId>
<artifactId>f1-interface-websocket</artifactId>
</dependency>在启动类中加标注：
@EnableFeignClients("com.jb.*.client")
@ComponentScan在下边的代码中调用WorkFlowControlClient进行流程操作
@Autowired
private WorkFlowControlClient workFlowControlClient;
@Override
publicvoid operWorkflow() {
//发送流程
TransferInfotransferInfo = newTransferInfo();
transferInfo.setContent("你好，这有一个流程");
transferInfo.setForkStep("34870934");//如果流程经过fork节点进行迁移，则该节点设置为fork节点的stepid。
transferInfo.setJoinStep("349875994");//如果流程经过join节点进行迁移，则该节点设置为join节点的stepid。
/*发送信息参数,该对象为list数组，里边存储了下发迁移的具体信息，如果不经过fork
节点则该集合仅有一个元素，进过fork节点可设置多个元素对应发送的多个环节，其子元素SendParam对象的属性有"
orderNo(业务数据主键),nextActorId(下一步执行者),orderType(流程对象类型),"
taskId(任务id，流程启动时设置为0),content(流程审批意见),stepId(迁移到的环节id),"
sendModel(发送模式,多条流程进行发送还是单条流程进行发送，1101702为多条，1101702为单条)"
isSendInteracStep(是否需要发送到分布式流程的交互节点，通常不需要进行设置，如果要迁移到交互节点设置为'true')"
interacStep(分布式流程需要迁移到的交互环节id)" + "carbonCopyPersons(list数组，设置发送到该环节接收站内消息的人员id)"
sendType(发送模式，如果为发送设置为'send',如果是回退设置为'back')*/
transferInfo.setSendParam(newArrayList<SendParam>(){
{
add(new SendParam(){
{
setOrderNo("orderNo");
setNextActorId("nextActorId");
setOrderType("orderType");
setTaskId("taskId");
setContent("content");
setStepId("stepId");
setSendModel("sendModel");
setIsSendInteracStep("isSendInteracStep");
setInteracStep("interacStep");
setCarbonCopyPersons(Arrays.asList(new String[]{"293749","2303948"}));
setSendType("sendType");
}
});
}
});
//设置一些附加的参数
transferInfo.setVariables(newHashMap<String, Object>(){
{
put("args1", "20973403297");
put("args2", "34083049549");
}
});
InvokeResult irt = workFlowControlClient.sendFlow(transferInfo);
//从当前待处理环节迁移到任意环节
/*BackParam任意环节发送对象，对应的属性介绍如下：orderNo:业务数据主键。
backTaskActorId:处理当前任务的处理人。nextActorId:迁移到的环节的任务处理者。content:审批意见。
orderType:流程对象标识taskId:当前处理任务的id。
sendModel:发送模式,多条流程进行发送还是单条流程进行发送，1101702为多条，1101702为单条backNodeName:迁移到的环节名称
isSendInteracStep:是否需要发送到分布式流程的交互节点，通常不需要进行设置，如果要迁移到交互节点设置为'true'
interacStep:分布式流程需要迁移到的交互环节id
carbonCopyPersons:list数组，设置发送到该环节接收站内消息的人员id*/
BackParam freeSendParam = new BackParam();
freeSendParam.setOrderNo("orderNo");
freeSendParam.setBackTaskActorId("backTaskActorId");
freeSendParam.setNextActorId("nextActorId");
freeSendParam.setContent("content");
freeSendParam.setOrderType("orderType");
freeSendParam.setTaskId("taskId");
freeSendParam.setSendModel("sendModel");
freeSendParam.setBackNodeName("backNodeName");
freeSendParam.setIsSendInteracStep("isSendInteracStep");
freeSendParam.setInteracStep("interacStep");
freeSendParam.setCarbonCopyPersons(Arrays.asList(new String[]{"293749","2303948"}));
irt = workFlowControlClient.sendFreeNode(freeSendParam);
//暂停流程
longpid = 1L;
irt = workFlowControlClient.cmdSuspendProcess(pid);
//恢复流程
pid = 1L;
irt = workFlowControlClient.cmdResumeTask(pid);
//发送流程到结束环节
longtaskId = 1L;
irt = workFlowControlClient.endFlow(taskId);
//通过任务id删除流程
taskId = 1L;
irt = workFlowControlClient.deleteFlowByTaskId(taskId);
//通过流程实例id删除流程
pid = 1L;
irt = workFlowControlClient.deleteFlowByPdId(pid);
//通过业务主键获取流程实例id
String orderNo = "2934792374928734987";
longpdid = workFlowControlClient.getPdIdByOrderNo(orderNo);
}
BD控件事件定制
就是模型类的脚本，现在使用的是在模型工具中选中类型右键挂接脚本，写一个类继承BaseClsScript，就可以对这个模型类的事件进行拦截处理。具体方法如下。
所用到的依赖：f1-interface-script
如下新建一个service, 继承 BaseClsScript
有创建前后、保存前后、删除前后、查询后，共七个事件，需要哪个事件就重写一下哪个事件。
然后在模型工具中对类型进行右键挂接脚本，输入当前微服务的id以及新做的service的id
Bp控件服务定制
对于一些非模型数据的控件，我们需要在后台给它们提供一些类来进行数据的操作
bp控件有bpgrid, bptree, combobox，具体实现如下。
引入依赖f1-starter-ui：
在启动类上加componentScan标注,添加对com.jb.ui包的扫描。
在启动类上加EntityScan标注,添加对新添加实体类的扫描。
@ComponentScan(basePackages={"com.jb.mst","com.jb.ui"})
@EntityScan("com.jb.mst.model")实体类就是一般的Hibernate实体类的基础上，在字段上加@FieldEditor和@JsonProperty
FieldEditor是字段的一些显示属性，JsonProperty是指明实体对象转成JSON时的字段对应的属性名
@Entity
@Table(name="tb_app_bdz", catalog="us_app")
public class TbAppBdz extends PersistClass {
/** TODO */
private static final long serialVersionUID = -8103749525304011660L;
@GenericGenerator(name = "generator", strategy = "com.jb.dao.id.UIDGenerator")
@Id
@GeneratedValue(generator = "generator")
@Column(name = "GUID", nullable = false, length = 42)
@FieldEditor(caption = "唯一标识", isReadOnly=true, dispIndex = 0, hidden = true)
@JsonProperty("GUID")
private String guid;
@Column(name = "OBJ_CAPTION", nullable = true, length = 200)
@FieldEditor(caption = "对象标识", isReadOnly=true, dispIndex = 1, hidden = true)
@JsonProperty("OBJ_CAPTION")
private String obj_caption;bpgrid的service 继承EntityOperationServiceAdapter
@Service("testBpGridService")
@Transactional(value="transactionManager", propagation=Propagation.REQUIRED)
publicclass TestBpGridService extends EntityOperationServiceAdapter<TbAppBdz> {
}
bptree的service 继承TreeService
@Service("testBpTreeService")
@Transactional(value="transactionManager", propagation=Propagation.REQUIRED)
public class TestBpTreeService extends TreeService {
//测试url: http://192.168.1.20:8081/zuul/f1-microserviceoftenuse/tree/query.do?service=testBpTreeService&filterStr={}&nodeAttr={"depth":0}&token_seat=token_seat&access_token=5f865d14-5efc-4522-a81c-882c6935ba66
@Autowired
private GenericDao genericDao;
@Override
public List<TreeNodeModel> query(TreeNodeModel queryModel, List<FilterModel> filterModels, UserModel userModel) {
List<TreeNodeModel> model = new ArrayList<TreeNodeModel>();
String sql = ""; // 如果是第0层
if (queryModel.getDepth() == 0) {
sql = "SELECT DEPT_ID,DEPT_NAME,IFNULL(SUPER_DEPT,'空') SUPER_DEPT " + " FROM US_SYS.TB_SYS_DEPARTMENT " + " WHERE SUPER_DEPT is null";
} else if (queryModel.getDepth() == 1) {
sql = "SELECT DEPT_ID,DEPT_NAME,IFNULL(SUPER_DEPT,'空') SUPER_DEPT " + " FROM US_SYS.TB_SYS_DEPARTMENT " + " WHERE SUPER_DEPT = '"
+ queryModel.getId()
+ "' AND (SFZF IS NULL or sfzf = 'F') AND DEPT_TYPE = 0100104 ORDER BY DEPT_NAME ";
} else {
System.out.println(queryModel.getId());
sql = "SELECT PERS_ID, PERS_NAME ,'' DN FROM US_SYS.TB_SYS_PERSON WHERE DEPT_ID = '" + queryModel.getId()
+ "'";
}
@SuppressWarnings("unchecked")
List<Object[]> list = (List<Object[]>) genericDao.getDataWithSQL(sql);
for (Object[] objs : list) {
TreeNodeModel tree = new TreeNodeModel(objs[0].toString(), objs[1].toString());
tree.setChecked(queryModel.isChecked());
if (queryModel.getDepth() == 2)
tree.setLeaf(true);
Map<String, String> attr = new HashMap<String, String>();
attr.put("bmbm", objs[2].toString());
tree.setAttr(attr);
model.add(tree);
}
return model;
}
@Override
public Map<Object, String> putDisplay(Set selectedValueSet) {
Map<Object, String> display = new HashMap<Object, String>();
DataTable table = null;
StringBuffer buffer = new StringBuffer();
Iterator it = selectedValueSet.iterator();
while (it.hasNext()) {
String dStr = (String) it.next();
if (buffer.length() > 0) {
buffer.append(",");
}
buffer.append("'");
buffer.append(dStr);
buffer.append("'");
}
String values = buffer.toString();
if (!StringUtils.isNullOrEmpty(values)) {
String sql = String.format(
"SELECT PERS_ID,PERS_NAME FROM US_SYS.TB_SYS_PERSON " + " WHERE PERS_ID in (%s) ", values);
table = genericDao.exeSql(sql);
}
for (int i = 0; i < table.getRows().size(); i++) {
DataRow dataRow = table.getRows().get(i);
display.put(dataRow.getValue(0), dataRow.getValue(1).toString());
}
return display;
}
}combobox的service 继承ComboBoxService
@Service("testComboboxService")
@Transactional(value="transactionManager", propagation=Propagation.REQUIRED)
public class TestComboboxService extends ComboBoxService {
//测试url: http://192.168.1.21:8088/zuul/f1-microserviceoftenuse/comboBox/query.do?service=testComboboxService&token_seat=token_seat&access_token=5f865d14-5efc-4522-a81c-882c6935ba66
@Autowired
private GenericDao genericDao;
@Override
public ComboBoxModel query(Map<String, ?> filterMap, boolean blankItem, UserModel userModel) {
String sql = "select code_name,code from us_sys.tb_sys_code where label_code='02001'";
@SuppressWarnings("unchecked")
List<Object[]> list = (List<Object[]>)genericDao.getDataWithSQL(sql);
ComboBoxModel cm = new ComboBoxModel();
if(list==null) {return cm;}
for(int i=0; i<list.size();i++){cm.addData(
new String[]{
list.get(i)[0].toString(),
list.get(i)[1].toString()
});
}
return cm;
}
@Override
public Map<Object, String> putDisplay(Set selectedValueSet) {
Map<Object, String> display = new HashMap<Object, String>();
DataTable table = null;
StringBuffer buffer = new StringBuffer();
Iterator it = selectedValueSet.iterator();
while (it.hasNext()) {
String dStr = (String) it.next();
if (buffer.length() > 0) {
buffer.append(",");
}
buffer.append("'");
buffer.append(dStr);
buffer.append("'");
}
String values = buffer.toString();
if (!StringUtils.isNullOrEmpty(values)) {
String sql = String.format(
"select code,code_name from us_sys.tb_sys_code where code in (%s) ", values);
table = genericDao.exeSql(sql);
}
for (int i = 0; i < table.getRows().size(); i++) {
DataRow dataRow = table.getRows().get(i);
display.put(dataRow.getValue(0), dataRow.getValue(1).toString());
}
return display;
}
}
把当前微服务的id和bp的service的beanid交给前台控件，就可以调用这些自定义的service
异构数据库支持
有时候对于同一个操作用到的sql在异构的数据库中sql语句是不同的，怎么才能把这些操作对于异构的数据库进行兼容呢，F1平台的解决方法如下。
首先要有依赖：f1-starter-configure 如果已经引入了f1-starter就不用再引入了
在application.properties中加参数
##异构数据库配置(true时每次请求都会加载)
platform.config.debugMode=true在resources下加resource.xml
以查询消息发送时间的sql为例，把几种数据库的sql写到这里边
下边用ResourceManager.getInstance().getDBSS("queryMsgSendTime")从resource.xml中读出对应当前数据库的sql
多数据源支持
有时候有的功能要对不同的数据源进行操作，比如A方法要对A数据库进行操作，同时B方法要对B数据库进行操作，对此F1平台的解决方法如下。
首先要在pom中引入f1-starter-data。已经引入了f1-starter就不用再单引了
启动类上用@Import引入DynamicDataSourceRegister 和 DynamicDataSourceAspect
在application中加入自定义的数据源配置ds1和ds2, 这时系统中连默认数据源，共有三个数据源
如下图中是在方法上使用自定义的数据源，就是加上@TargetDataSource("数据源的名字")，也可以加在类上
用jdbc的方式：
用genericDao的方式：
即时推送
有时候需要把消息即时推送到前台，比如给正在登录的用户一些消息提醒，就需要把数据推送到页面上，F1平台的解决方法如下。
加入依赖：
<dependency>
<groupId>com.joinbright.f1</groupId>
<artifactId>f1-interface-websocket</artifactId>
</dependency>在启动类上加标注：@EnableFeignClients("com.jb.**.client")
消息推送示例如下：
@ApiOperation(value = "即时推送示例", httpMethod = "GET", response = String.class, notes = "即时推送示例")
@RequestMapping(value = "immediatePush", method=RequestMethod.GET)
publicvoid immediatePush() {
Message message = new Message("topicid1", "identityId", "消息内容", "发送者", "消息类型");
webSocketClient.sendMessage(message );
}其中消息内容是字符串，发送者是pers_id，消息类型是（whole：发送消息体Json字符串、content：仅发送消息内容）
jms消息
jms可以解决一个地方发生了某个事件后，可以触发连锁的多个地方的操作，是观察者模式的具体实现，是消息队列的具体应用，F1平台用的activeMQ消息队列，下面是具体的实现方法。
加入依赖：
<dependency>
<groupId>com.joinbright.f1</groupId>
<artifactId>f1-message</artifactId>
</dependency>在application.properties中配置消息中间件为jms
# 使用jms或者是kafka作为消息中间件(jms/kafka)
platform.config.messageSwitch=jmsjms生产者
@Service("jmsSendService")
public class JmsSendServiceImpl {
publicvoid jmsSend() {
msgSender.send("topic01","发送jms消息");
}
}jms消费者
@Component
public classMyJmsListener {
@JmsListener(destination = "topic01",containerFactory = "myFactory")
public void listen1(String foo) {
System.out.println(foo);
}
}以上jms的配置只适用于生产者和消费者在同一个项目中（因为默认是使用的是内存中的activeMQ，所以二者在不同的项目中无法消息监听），这种情况在不启动activeMQ Server时用于测试还是可以的。
下边介绍一下用activeMQ Server来实现jms
在生产者和消费者两边的application.properties中都加参数：
指定activeMQ Server的地址
# 使用jms或者是kafka作为消息中间件(jms/kafka)
platform.config.messageSwitch=jms
##################### 给jms配置的activeMQ配置
spring.activemq.broker-url=tcp://localhost:61616
spring.activemq.user=admin
spring.activemq.password=adminkafka消息
kafka所实现的功能和jms是类似的，二者是可以相互替换，kafka和jms的activeMQ的不同点见链接：
消息中间件ActiveMQ与Kafka对比之Kafka 。下边是F1平台对kafka的实现方法。
加入依赖：
<dependency>
<groupId>com.joinbright.f1</groupId>
<artifactId>f1-message</artifactId>
</dependency>在application.properties中加kafka连接参数：
#Kafka配置
#地址
platform.config.kafka_server=127.0.0.1:64846
#消费者组号
platform.config.kafka_consumer_group_id=testT
#消费者是否自动提交
platform.config.kafka_consumer_auto_commit=false
#消费者提交间隔
platform.config.kafka_consumer_commit_interval=100
#消费者session超时时间
platform.config.kafka_consumer_session_timeout=15000
#在ZK中没有offset值时,consumer应该从哪个offset开始消费
platform.config.kafka_consumer_auto_offset_reset=earliest
#Key反序列化类
platform.config.kafka_consumer_key_deserializer=org.apache.kafka.common.serialization.IntegerDeserializer
#value反序列化类
platform.config.kafka_consumer_value_deserializer=org.apache.kafka.common.serialization.StringDeserializer
#生产者重试次数
platform.config.kafka_producer_retries=0
#生产者数据块大小
platform.config.kafka_producer_batch_size=16384
#生产者逗留时间
platform.config.kafka_producer_linger_ms=1
#生产者缓存的大小
platform.config.kafka_producer_buffer_memory=33554432
#Key序列化类
platform.config.kafka_producer_key_serializer=org.apache.kafka.common.serialization.IntegerSerializer
#value序列化类
platform.config.kafka_producer_value_serializer=org.apache.kafka.common.serialization.StringSerializer
#监听容器的数量（并发的数量）
platform.config.kafka_concurrency=3
#监听容器poll的超时时长
platform.config.kafka_poll_timeout=3000在application.properties中配置消息中间件为kafka
# 使用jms或者是kafka作为消息中间件(jms/kafka)
platform.config.messageSwitch=kafka
kafka生产者：
@Service("kafkaSendService")
public class KafkaSendServiceImpl implements KafkaSendService {
@Autowired
private MsgSender msgSender;
/**
* @Title: kafkaSend
* @Description: kafka消息发送
* @param
* @return void
* @throws
*/
public void kafkaSend() {
msgSender.send("topic01", "发送kafka消息");
}
kafka消费者：
@Component
public class MyKafkaListener {
@KafkaListener(topics = "topic01")
public void listen1(String foo) {
System.out.println(foo);
}
}自动装配组件开发
类似于springboot 的starter,提供一些开箱即用的功能。我们以f1-starter-data为例，来初始化sessionFactory，transactionManager来说明自定义starter
编写pom文件
<parent>
<groupId>com.joinbright.f1</groupId>
<artifactId>f1-parent</artifactId>
<version>3.0.0-SNAPSHOT</version>
</parent>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<optional>true</optional>
</dependency>
编写一个DaoAutoConfigure类内容如下，我们需要使用@Configuration注解我们的类
@Configuration
public class DaoAutoConfigure {
@Autowired
private EntityManagerFactory entityManagerFactory;
@Bean("sessionFactory")
public SessionFactory getSessionFactory() {
if (entityManagerFactory.unwrap(SessionFactory.class) == null) {
throw new NullPointerException("factory is not a hibernate factory");
}
return entityManagerFactory.unwrap(SessionFactory.class);
}
@Bean("genericDao")
// @Autowired
public GenericDao getDao(SessionFactory sessionFactory){
GenericDao dao=new GenericDaoImpl();
dao.setSessionFactory(sessionFactory);
return dao;
}
//txManager事务开启
@Bean("transactionManager")
public HibernateTransactionManager txManager(SessionFactory sessionFactory) throws SQLException {
HibernateTransactionManager hibernateTransactionManager = new HibernateTransactionManager();
hibernateTransactionManager.setSessionFactory(sessionFactory);
return hibernateTransactionManager;
}
}
最后resources/META-INF/spring.factories中加入这个DaoAutoConfigure：
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.jb.data.autoconfigure.DaoAutoConfigure
这样一个标准的starter就编写完成，然后我们只需要在具体微服务中引入这个starter就能做到开箱即用。
interface组件开发
当其它
微服务想要调用当前微服务中的方法时，我们需要提供一个feign客户端对外开放这些服务。具体的实现方法如下。
我们当前微服务的名字：f1-microServiceOftenUse，其中有一个控制器：HelloWorldController, 我们想要把这个控制器中的功能暴露给其它的服务。
我们新建一个maven项目命名为f1-interface-microServiceOftenUse
pom 中引入如下依赖
<parent>
<artifactId>f1-parent</artifactId>
<groupId>com.joinbright.f1</groupId>
<version>3.0.0-SNAPSHOT</version>
</parent>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-feign</artifactId>
</dependency>然后在新建一个类com.jb.mst.client.HelloWorldControllerClient
@FeignClient(name="f1-microServiceOftenUse")
public interface HelloWorldControllerClient {
@RequestMapping(method = {RequestMethod.GET}, value = "/first/operModel.do")
String gethello(String guid);
}
对于其他微服务而言只需要引入f1-interface-microServiceOftenUse，就能访问HelloWorldController中的方法了
具体调用方法请参考：使用模型服务、使用工作流服务、BD控件事件定制、即时推送（websocket）这几个部分都是调用的对应微服务的interface来实现的。
服务调用
指的就是微服务间调用服务，有时候一个微服务中的功能要依赖其它微服务的功能来实现，这时就需要服务间的调用，有两种方式：1.Ribbon方式（serviceId可以动态改变）、2.Fegin方式（serviceId是静态的），下边是具体的实现方法。
Ribbon 方式访问
这里通过ribbon方式访问model-service中的attr/cmdGetAttribute.do方法
通过postParameters.add方法添加服务需要的变量。
@RestController
public class RibbonController extends BaseAgent{
private static final Log log = LogFactory.getLog(RibbonController.class);
@Autowired
private RestTemplate restTemplate;
private String serviceid="model-service";
@RequestMapping("/ribbon")
@ResponseBody
public String service1() throws Exception {
HttpHeaders headers = setHeader();
// 获取请求参数
MultiValueMap<String, String> postParameters = new LinkedMultiValueMap<String, String>();
postParameters.add("guid", "00370C16-4CA9-43BE-88B4-4DA5E4FF4FB8-00096");
String url = "http://" + serviceid + "/attr/cmdGetAttribute.do";
HttpEntity<MultiValueMap<String, String>> requestEntity = new HttpEntity<MultiValueMap<String, String>>(
postParameters, headers);
return restTemplate.postForObject(url, requestEntity, String.class);
}
}
Feign方式
我们需要编写feignClient客户端, 方式和上一小节中的interface组件的实现是一样的。
@FeignClient(name="model-service")
public interface FeginClient {
@RequestMapping(method = {RequestMethod.POST}, value = "/attr/cmdGetAttribute.do")
String gethello(String guid);
}
在调用feign接口的地方，将上一步的FeignClient 注入进来。下边示例是在一个控制器中调用了feignClient
@RestController
public class FeignControl {
@Autowired
private FeignClient feginClient;
@RequestMapping("/feign")
public String fegin(){
return feignClient.gethello("00370C16-4CA9-43BE-88B4-4DA5E4FF4FB8-00096");
}
}
服务事件扩展
有时候平台中一些公共的service的处理结果不满足实际的需要，这时候就需要用事件扩展，事件扩展就是对平台中一些暴露出扩展点service进行扩展，用自定义的方法来实现自己的逻辑。具体实现方法如下。
这里以扩展usermenu的service为例
1.引入依赖（如果已经引入了f1-starter就不用再单独引入f1-starter-listener了）：
<dependency>
<groupId>com.joinbright.f1</groupId>
<artifactId>f1-starter-listener</artifactId>
</dependency>2.加入配置项：
# 启动后执行类（自动注册本服务中扩展类）
context.listener.classes=com.jb.listener.client.starter.RegisterListener
# 通用接口实现类
platform.config.listeners=服务名:扩展类型
服务名是自定义的beanid， 扩展类型是被扩展的类型，
# 启动后执行类（自动注册本服务中扩展类）
context.listener.classes=com.jb.listener.client.starter.RegisterListener
# 通用接口实现类
platform.config.listeners=usermenu:usermenuExtend:0
3.扩展类
@Service("usermenuExtend")
public class UserMenuExtend extends Listener {
@Override
public Object extend(Event event) {
DataTable t = (DataTable) event.getOrignalData();
System.out.println("事件中数据量为："+t.getRows().size());
System.out.println("修改后，事件中数据量为："+t.getRows().size());
return t;
}
}然后先启动usermenu原service的微服务，再启动当前扩展的微服务就可以覆盖之前的usermenu服务了。
注：对于一个原service, 只能有一个扩展，如果再有其它的注册就会报错。
407
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
