Titan Framework 内部接口与函数说明书

最新推荐文章于 2021-07-26 00:26:57 发布
最新推荐文章于 2021-07-26 00:26:57 发布
阅读量369 收藏
点赞数
文章标签： ACTOR 微服务 MVP 框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Titan_Framework/article/details/80844577
版权

HTTP与网络

Spring风格的Restful的Controller：

RestfulController 通用Restful API Controller

–org.titan.framework.facade.controller.RestfulController

方法

参数

返回值

说明

getCreateCommand

arg0-ServiceName<String>

arg1-body<T>

Command

默认捕捉HTTP  POST请求

API结构示例：

https://{base_url}/{path}/{serviceName}

Body:json

getDeleteCommand

arg0-ServiceName<String>

arg1-id<String>

Command

默认捕捉HTTP  DELETE请求

API结构示例：

https://{base_url}/{path}/{serivceName}/{id}

body:空

getGetCommand

arg0-serviceName<String>

arg1-id<String>

Command

默认捕捉HTTP  GET请求

API结构示例：

https://{base_url}/{path}/{serviceName}/{id}

body:空

getPatchCommand

arg0-serviceName<String>

arg1-id<String>

arg2-body<String>

Command

默认捕捉HTTP  PATCH请求

API结构示例:

https://{base_url}/{path}/{serviceName}/{id}

body:json

getPutCommand

arg0-serviceName<String>

arg1-id<String>

arg2-body<String>

Command

默认捕捉HTTP  PUT请求

API结构示例：

http://{base_url}/{path}/{serviceName}/{id}

body:json

getQueryCommand

arg0-serviceName<String>

arg1-queryObject<Object>

Command

参自定义部分

 

RestfulController进行HTTP API Path注释同Spring风格

@RestController

@RequestMapping("/otp")

public class ADemoController extends RestfulController

 

Tips：RestfulController各方法中的ServiceName可以用于区分API版本号，并且进行API版本兼容处理，例如https://{base_url}/login/v1  [POST]。

 

完整的RestfulController实例

@RestController

@RequestMapping("/otp")

public class ADemoController extends RestfulController {

    @Override

    protected <T> Command<?> getCreateCommand(String service, T body) {

    try {

    System.out.println("service - " + service);

    String _body = (String) body;

    DemoAEntity entity = JsonParser.getObject(_body, DemoAEntity.class);

    return new Create<DemoAEntity>(entity);

        }catch(Exception e) {

        return null;

        }

    }

 

    @Override

    protected Command<?> getDeleteCommand(String service, String id) {

    DemoAEntity entity = new DemoAEntity();

    entity.setId(id);

        return new Delete<DemoAEntity>(entity);

    }

 

    @Override

    protected Command<?> getGetCommand(String arg0, String arg1) {

        return null;

    }

 

    @Override

    protected Command<?> getPatchCommand(String arg0, String arg1, String arg2) {

        return null;

    }

 

    @Override

    protected Command<?> getPutCommand(String arg0, String arg1, String arg2) {

        return null;

    }

 

    @Override

    protected Command<?> getQueryCommand(String arg0, Object arg1) {

    return null;

    }

}

QueryController 通用查询专用API Controller

–org.titan.framework.facade.controller.QueryController

方法

参数

返回值

说明

queryCommand

arg0-serviceName<String>

arg1-id<String>

Command.Query

默认步骤HTTP GET请求

API结构示例:

http://{base_url}/{path}/{serviceName}/{id}

body:空

完整的QueryController实例

@RestController

@RequestMapping("/cfind")

public class CDemoFindController extends QueryController {

 

    @Override

    protected Query<?> queryCommand(String serviceName, String id) {

        CDemoEntity entity = new CDemoEntity();

        entity.setName(serviceName);

        entity.setCode(id);

        return new Query<CDemoEntity>(entity);

    }

 

    @Inject

    DemoCFinder finder;

 

    @RequestMapping(method = { RequestMethod.GET }, headers = { "Accept=application/json" }, produces = {"application/json" })

    public ResponseEntity<Object> query() {

        Result result = finder.finWithPureSQL();

        return ResponseBuilder.instance().status(result.getStatusCode()).body(toJson(result.getEntities())).build();

    }

}

org.titan.framework.facade.controller的自定义方式

Titan Framework对Controller的自定义方式类似Spring风格，如果曾经使用过SpringMVC的用户将会很快上手。

@RequestMapping(method = { RequestMethod.GET }, headers = { "Accept=application/json" }, produces = {"application/json" })

@Override

protected Command<?> getQueryCommand(String arg0, Object arg1) {

   return null;

}

CommandHandler&Command 通用指令模型

–org.titan.framework.facade.application.CommandHandler

–org.titan.framework.facade.application.Command

Titan Framework中采用如下逻辑进行Command捕捉与传递。

–第一步：Controller中return一个Command至Titan的Controller基类；

–第二步：Titan的Controller基类中将会完成Command类型的识别与自动匹配；

–第三步：Titan将Command发送到对应的应用层CommandHandler（注意：必须有@CmdHandler注释）

 

一个简单的CommandHandler案例如下：

@CmdHandler

public class DemoACreateHandler implements CommandHandler<Create<DemoAEntity>> {

    @Override

    public Result handle(Create<DemoAEntity> cmd) {

        DemoAEntity entity = cmd.getEntity();

        System.out.println(entity.getName() + "," + entity.getText());

        HelloWorldEntity mEntity = new HelloWorldEntity();

        Result result = Result.create(true, mEntity);

        return result;

    }

}

Command&Command类型

Command是Titan框架中的指令单元，用来关联Controller与对应的具体处理逻辑，实现Controller与逻辑处理的解耦。Titan Framework为用户预置了下面这些Command类型，大家可以直接使用。

类型

说明

Command.Create

Create类型的Command

Command.Delete

Delete类型的Command

Command.Error

Error类型的Command

Command.Get

Get类型的Command

Command.Patch

Patch类型的Command

Command.Query

Query类型的Command

Command.Put

Put类型的Command

当然，大家也可以通过实现Command接口来自定义自己的Command。对于自定义Command，Titan Framework同样提供自动匹配支持。

Command中实现了以下默认方法：

方法

参数

返回值

说明

getCache

String

Object

调取Command缓存中的全局数据

putCache

<String,Object>

Void

将一个数据放入Command缓存中

getEntity

Void

DataEntity

获取绑定在Command中的DataEntity

getEntityClassT

Void

Class

获取绑定在Command中DataEntity的具体类型

Result与Result的使用

Result是Titan Framework中通用返回值的包装类，通过Result可以直接获取结果、状态、错误信息等。 

Result有以下构造方式：

方式

参数

说明

Result.create(boolean,dataEntity)

boolean-成功状态标志位

dataEntity-携带的具体数据

可以用于微服务之间的返回；

可以用于CommandHandler对API层的返回，此时dataEntity将会作为HTTP Response中的json body，此时http code默认为200；

Result.create(boolean, int,dataEntity)

boolean-成功状态标志位

Int-http状态码

dataEntity-携带的具体数据

可以用于微服务之间的返回；

可以用于CommandHandler对API层的返回，此时dataEntity将会作为HTTP Response中的json body，此时http code为输入的int参数

Result.create(boolean,String,String)

boolean-成功状态标志位

String-错误码

String-错误信息

 

Result.create(boolean,int,String,String)

boolean-成功状态标志位

int-状态码

String-错误码

String-错误消息

 

Titan内置的Result信号类型，可以快速构建对应的result：

类型

说明

Result.Status.Acceptable

远端微服务接受某项请求;返回码202

Result.Status.AvailableNotEnough

支付模块中可用金额不足；返回码513

Result.Status.Conflict

数据冲突；返回码409

Result.Status.Continue

串型处理同步；返回码100

Result.Status.Fault

错误反馈；返回码 无；内部使用

Result.Status.Forbidden

禁止操作；返回码 403

Result.Status.Found

数据库中存在指定数据；返回码 302

Result.Status.Gone

定向数据已销毁；返回码 410

Result.Status.MethodNotAllowed

微服务操作权限不足；返回码 405

Result.Status.NoContent

空数据内容提示；返回码 204

Result.Status.NoFound

数据库中无指定数据；返回码 404

Result.Status.NotAcceptable

微服务参数错误/微服务拒绝远程调用；返回码 406

Result.Status.Ok

成功；返回码 无；内部使用

Result.Status.Processing

特定事务处理中；返回码 102

Result.Status.RequiredPayment

待支付标志；返回码 402

Result.Status.ServerError

服务器内部错误；返回码 500

Result.Status.TimeOut

超时；返回码 408

Result.Status.Unauthorized

Token无效；返回码 401

Result的方法：

方法

参数

返回值

说明

getEntity

Void

DataEntity

获取Result中绑定的DataEntity

getErrors

Void

String

获取错误码

getErrorMessage

Void

String

获取错误信息

getStatusCode

Void

int

获取状态码

微服务远程调度

Publish&EventHandler

–org.titan.framework.facade.kit.Publish

–org.titan.framework.facade.event.EventHandler

Publish是Titan Framework的微服务远程调用入口，用于有针对性地向远程服务发起请求事件。

Publish有以下方法：

方法

参数

返回值

说明

Pipto

ParallelContext

Actor

void

同时请求多个微服务同时响应一个事件；Titan Framework高阶版本特性；

Send

ParallelContext

Result

请求一个远程微服务响应事件，并异步等待回复

Send

LocalContext

Result

请求一个本地微服务响应事件，并异步等待回复

Tell

PublishContext

void

告知一个远程微服务响应事件，但是不等待任何回复

Proxy

TransportContext,

Actor

Result

请求某个远程微服务作为代理;Titan Framework高阶版本特性；

Publish的使用示例：

Send模式（Remote）

@CmdHandler

public class DemoACreateHandler implements CommandHandler<Create<DemoAEntity>> {

 

    @Override

    public Result handle(Create<DemoAEntity> cmd) {

        DemoAEntity entity = cmd.getEntity();

        System.out.println("vvvvv");

        System.out.println(entity.getName() + "," + entity.getText());

        Result result = Publish.Send(Ways.Remote(Paths.DemoB.service.getServerName(), new DemoACreateEvent())).Retry();

        return result;

    }

 

}

Send模式（Local）

@CmdHandler

public class CreateHandler implements CommandHandler<Create<CDemoEntity>> {

 

    @Override

    public Result handle(Create<CDemoEntity> cmd) {

        Publish.Send(Ways.Local(DemoCEvent.create(cmd.getEntity()))).Retry();

        return Result.Status.Ok;

    }

 

}

public class DemoCEvent extends AppEvent {

    private static final long serialVersionUID = 854614362533549305L;

    static public enum Status {

        Create(1), Update(2), Delete(3);

        final int value;

        Status(int value) {

            this.value = value;

        }

    }

 

    public final Status status;

    Object data;

    DemoCEvent(Status status) {

        this.status = status;

    }

    <T> DemoCEvent init(T data) {

        this.data = data;

        return this;

    }

 

    @SuppressWarnings("unchecked")

    public <T> Optional<T> getData() {

        return (Optional<T>) Optional.ofNullable(data);

    }

 

    static public <T> DemoCEvent create(T entity) {

        return new DemoCEvent(Status.Create).init(entity);

    }

 

    static public <T> DemoCEvent update(T entity) {

        return new DemoCEvent(Status.Update).init(entity);

    }

 

    static public <T> DemoCEvent delete(T entity) {

        return new DemoCEvent(Status.Delete).init(entity);

    }

 

}

与Publish相对应的是其他微服务的EventHandler，Publish发送Event，EventHandler接收响应Event。

EventHandler和CommandHandler类似，通过Event的类型来进行远程匹配。

EventHandler使用示例：

@EvtHandler(Role = "demo", Service = "c")

public class DemoCEventHandler implements EventHandler<DemoCEvent> {

    @Inject

    DemoCRespository respository;

 

    @Override

    public void handle(DemoCEvent event) {

        System.out.println("-- demo.c-- event... ");

        Result result = Result.Status.Ok;

        switch (event.status) {

        case Create:

            result = onCreate(event.getData());

            break;

        case Update:

            result = onUpdate(event.getData());

            break;

        case Delete:

            result = onDelete(event.getData());

            break;

        default:

            break;

        }

        Feedback.content(event, result);

    }

 

    Result onCreate(Optional<CDemoEntity> optional) {

        return optional.map(entity -> {

            entity.setId(AggregateId.generate().getId());

            return respository.create(entity);

        }).orElse(Result.Status.Fault);

    }

 

    Result onUpdate(Optional<CDemoEntity> opt) {

        return opt.map(entity -> {

            // -- maybe validate entity

            return respository.update(entity);

        }).orElse(Result.Status.Fault);

    }

 

    Result onDelete(Optional<CDemoEntity> opt) {

        return opt.map(entity -> {

            return respository.delete(entity);

        }).orElse(Result.Status.Fault);

    }

 

}

EventHandler中关键方法为Feedback.content()，用来通过非阻断的方式将处理结果返回至调用者。

方法

参数

返回值

说明

Feedback.content

AppEvent-远端Event

Result-返回结果

Void

通过非阻断式方式进行远程反馈

Tips：自定义AppEvent和Result中都可以携带数据进行返回，Titan官方不建议返回数据过大，如果需要返回大量数据或者二进制流数据，可以通过Event驱动加MessageQueue的方式进行处理。

 

数据库&消息队列支持

Titan Framework对MySql、MongoDB、Redis提供直接支持。

Titan Framework的MySql支持

Titan与Mysql的对接包括以下三部分：

–conf包下的mysql.properties

–spring包下的application-dynamic-ds-context.xml、application-context.xml

–基于Titan SpringMysqlRepository、SpringMysqlFindRepository的功能模块

其中SpringMysqlRepository是数据库写模型，SpringMysqlFindRepository是数据库读模型。

SpringMySqlRepository用法如下：

@Repository

public class DemoCRespository extends SpringMysqlRepository<CDemoEntity> {

 

    @Override

    protected String getTableName() {

        return "testentity";

    }

 

}

@EvtHandler(Role = "demo", Service = "c")

public class DemoCEventHandler implements EventHandler<DemoCEvent> {

 

    @Inject

    DemoCRespository respository;

 

    @Override

    public void handle(DemoCEvent event) {

 

        System.out.println("-- demo.c-- event... ");

        Result result = Result.Status.Ok;

 

        switch (event.status) {

        case Create:

            result = onCreate(event.getData());

            break;

        case Update:

            result = onUpdate(event.getData());

            break;

        case Delete:

            result = onDelete(event.getData());

            break;

        default:

            break;

        }

        

        Feedback.content(event, result);

    }

 

    Result onCreate(Optional<CDemoEntity> optional) {

        return optional.map(entity -> {

            entity.setId(AggregateId.generate().getId());

            return respository.create(entity);

        }).orElse(Result.Status.Fault);

    }

 

    Result onUpdate(Optional<CDemoEntity> opt) {

        return opt.map(entity -> {

            // -- maybe validate entity

            return respository.update(entity);

        }).orElse(Result.Status.Fault);

    }

 

    Result onDelete(Optional<CDemoEntity> opt) {

        return opt.map(entity -> {

            return respository.delete(entity);

        }).orElse(Result.Status.Fault);

    }

SpringMysqlRepository中包含以下方法：

方法

参数

返回值

说明

Create

DataEntity

Result

创建

Update

DataEntity

Result

更新

Delete

DateEntity

Result

删除

Load

String-Id

Result

读取

UfwCreate

DataEntity

Void

原子创建事务

UfwUpdate

DataEntity

Void

原子更新事务

UfwDelete

DataEntity

Void

原子删除事务

SpringMysqlFindRepository示例如下：

@Repository

public class DemoCFinder extends SpringMysqlFindRepository<CDemoEntity> {

 

    @Override

    protected String getTableName() {

        return "testentity";

    }

 

    // pure SQL fetch

    public Result finWithPureSQL() {

        String sql = " select * from " + getTableName();

        List<Map<String, Object>> records = Optional.ofNullable(DSLContext().fetch(sql)).map(list -> {

            return DSLUtility.convertList(list);

        }).orElse(null);

        return Optional.ofNullable(records).map(ls -> {

            return Result.create(true, ls);

        }).orElse(Result.Status.NoFound);

    }

 

}

mysql.properties示例如下：

#Database Configuration

df.db.driver=com.mysql.cj.jdbc.Driver

# for master

master.db.url=jdbc:mysql://127.0.0.1:3306/bentest?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=true

master.db.username=

master.db.password=

# for slave

slave.db.url=jdbc:mysql://127.0.0.1:3306/bentest?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC&useSSL=true

slave.db.username=

slave.db.password=

#jOOQ Configuration

jooq.sql.dialect=MYSQL

 

#useUnicode=true&characterEncoding=UTF-8&useSSL=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC

application-context.xml示例如下：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

        http://www.springframework.org/schema/beans     

        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-3.1.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

<context:annotation-config />

<context:component-scan base-package="org.titan.framework org.titan.loginRegister" />

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="locations">

<list>

    <value>file:**/conf/mysql.properties</value>

<value>file:**/conf/redis.properties</value>

</list>

</property>

<property name="ignoreUnresolvablePlaceholders" value="true" />

</bean>

<import resource="application-redis-context.xml" />

<import resource="application-mongoDB-context.xml" />

</beans>

application-dynamic-ds-context.xml示例如下：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"

xmlns:jdbc="http://www.springframework.org/schema/jdbc"

xsi:schemaLocation="

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-4.1.xsd

http://www.springframework.org/schema/aop

http://www.springframework.org/schema/aop/spring-aop-4.1.xsd   

    http://www.springframework.org/schema/tx

    http://www.springframework.org/schema/tx/spring-tx-4.1.xsd

    http://www.springframework.org/schema/context

    http://www.springframework.org/schema/context/spring-context-4.1.xsd

    http://www.springframework.org/schema/jdbc

    http://www.springframework.org/schema/jdbc/spring-jdbc-4.1.xsd">

<bean id="dsMaster" class="com.jolbox.bonecp.BoneCPDataSource" destroy-method="close">

<property name="driverClass" value="${df.db.driver}" />

<property name="jdbcUrl" value="${master.db.url}" />

<property name="username" value="${master.db.username}" />

<property name="password" value="${master.db.password}" />

</bean>

<bean id="dsSlave" class="com.jolbox.bonecp.BoneCPDataSource" destroy-method="close">

<property name="driverClass" value="${df.db.driver}" />

<property name="jdbcUrl" value="${slave.db.url}" />

<property name="username" value="${slave.db.username}" />

<property name="password" value="${slave.db.password}" />

</bean>

<bean id="dataSource" class="org.titan.framework.core.integration.sql.storage.DynamicDataSource">

<property name="targetDataSources">

<map key-type="org.titan.framework.core.integration.sql.storage.DataSourceType">

<entry key="dsDefault" value-ref="dsMaster"></entry>

</map>

</property>

<property name="defaultTargetDataSource" ref="dsMaster"></property>

</bean>

<bean id="lazyConnectionDataSource" class="org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy">

<constructor-arg ref="dataSource" />

</bean>

<bean id="transactionAwareDataSource" class="org.springframework.jdbc.datasource.TransactionAwareDataSourceProxy">

<constructor-arg ref="lazyConnectionDataSource" />

</bean>

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<property name="dataSource" ref="lazyConnectionDataSource" />

</bean>

 

<bean class="org.jooq.impl.DataSourceConnectionProvider" name="connectionProvider">

<constructor-arg ref="transactionAwareDataSource" />

</bean>

<bean id="dslContext" class="org.jooq.impl.DefaultDSLContext">

<constructor-arg ref="jooqConfig" />

</bean>

<bean id="exceptionTranslator"

class="org.titan.framework.core.integration.sql.transaction.ExceptionTranslator" />

<bean class="org.jooq.impl.DefaultConfiguration" name="jooqConfig">

<property name="SQLDialect">

<value type="org.jooq.SQLDialect">${jooq.sql.dialect}</value>

</property>

<property name="connectionProvider" ref="connectionProvider" />

<property name="executeListenerProvider">

<array>

<bean class="org.jooq.impl.DefaultExecuteListenerProvider">

<constructor-arg index="0" ref="exceptionTranslator" />

</bean>

</array>

</property>

</bean>

</beans>

Titan Framework的MongoDB支持

Titan与MongoDB的对接包括以下两部分：

–spring包下的application-mongoDB-context.xml、application-context.xml

–conf包下的mongoDB.properties

基于Titan MongodbRepository的功能模块

其中需要实现StorageDataProcessor.Mongo。

MongodbRepository用法如下：

@Repository

public class MongodbRepository implements StorageDataProcessor.Mongo {

@Override

public MongoDBConverter extConverter() {

// TODO Auto-generated method stub

return null;

}

public List<User> queryList(User user) {

Curd crud = curd();

List<User> list = new ArrayList<User>();

    list = crud.queryByCondition(MongoDBQueryCondition.Condition(query -> {

        query.Table(User.class.getSimpleName(), User.class).Condition("Phone", user.getPhone());

    }));

    return list ;

}

}

application-mongoDB-context.xml示例如下：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

    xmlns:mongo="http://www.springframework.org/schema/data/mongo"

    xsi:schemaLocation="http://www.springframework.org/schema/beans

               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

               http://www.springframework.org/schema/data/mongo

            http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">

    <mongo:mongo-client host="${mongo.host}" port="${mongo.port}" id="mongo">  

       <mongo:client-options write-concern="SAFE"/>  

    </mongo:mongo-client> 

    <mongo:db-factory  id="mongoDbFactory" dbname="${mongo.dbname}" mongo-ref="mongo" />  

 

    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  

       <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />  

    </bean>   

 

</beans>

application-context.xml示例如下：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

        http://www.springframework.org/schema/beans     

        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-3.1.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

<context:annotation-config />

<context:component-scan base-package="org.titan.framework org.titan.loginRegister" />

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="locations">

<list>

    <value>file:**/conf/mysql.properties</value>

<value>file:**/conf/redis.properties</value>

                <value>file:**/conf/mongoDB.properties</value>

</list>

</property>

<property name="ignoreUnresolvablePlaceholders" value="true" />

</bean>

<!-- <import resource="application-dynamic-ds-context.xml" /> -->

<import resource="application-redis-context.xml" />

<import resource="application-mongoDB-context.xml" />

</beans>

mongoDB.properties示例如下：

mongo.host=127.0.0.1

mongo.port=27017

mongo.dbname=loginRegister

Titan Framework的Redis支持

Titan与Mysql的对接包括以下三部分：

–spring包下的application-redis-context.xml、application-context.xml

–conf包下的redis.properties

–基于Titan ShardedJedisPool的功能模块

ShardedJedisPool用法如下：

@EvtHandler(Role = "loginRegister", Service = "b")

public class CreateOtpEventHandler implements EventHandler<OtpCreateEvent> {

 

@Resource(name = "shardedJedisPool")

private ShardedJedisPool shardedJedisPool;

@Override

public void handle(OtpCreateEvent event) {

String phone = event.getPhone();

ShardedJedis jedis = null;

try {

jedis = shardedJedisPool.getResource();

jedis.setex(phone, 10*60, phone);

} finally {

if (jedis != null) {

jedis.close();

}

}

return;

 

}

 

}

application-redis-context.xml用法如下：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:jdbc="http://www.springframework.org/schema/jdbc"

xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd

            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd

            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd

            http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">

 

<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">

 

<property name="maxIdle" value="${jedisPool.maxIdle}" />

<property name="minIdle" value="${jedisPool.minIdle}" />

 

<property name="testOnBorrow" value="${jedisPool.testOnBorrow}" />

<property name="testOnReturn" value="${jedisPool.testOnReturn}" />

 

<property name="timeBetweenEvictionRunsMillis" value="${jedisPool.timeBetweenEvictionRunsMillis}" />

<property name="testWhileIdle" value="${jedisPool.testWhileIdle}" />

<property name="minEvictableIdleTimeMillis" value="${jedisPool.minEvictableIdleTimeMillis}" />

<property name="softMinEvictableIdleTimeMillis" value="${jedisPool.softMinEvictableIdleTimeMillis}" />

<property name="numTestsPerEvictionRun" value="${jedisPool.numTestsPerEvictionRun}" />

</bean>

 

 

<bean id="shard-node-01" class="redis.clients.jedis.JedisShardInfo">

<constructor-arg index="0" value="${jedisPool.shard1.host}" />

<constructor-arg index="1" type="int" value="${jedisPool.shard1.port}" />

<property name="password" value="${jedisPool.shard1.password}" />

</bean>

 

<bean id="shardedJedisPool" class="redis.clients.jedis.ShardedJedisPool">

<constructor-arg index="0" ref="jedisPoolConfig" />

<constructor-arg index="1">

<list>

<ref bean="shard-node-01" />

</list>

</constructor-arg>

</bean>

</beans>

application-context.xml用法如下：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="

        http://www.springframework.org/schema/beans     

        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd

        http://www.springframework.org/schema/context

        http://www.springframework.org/schema/context/spring-context-3.1.xsd

        http://www.springframework.org/schema/mvc

        http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">

<context:annotation-config />

<context:component-scan base-package="org.titan.framework org.titan.loginRegister" />

<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

<property name="locations">

<list>

    <value>file:**/conf/mysql.properties</value>

<value>file:**/conf/redis.properties</value>

</list>

</property>

<property name="ignoreUnresolvablePlaceholders" value="true" />

</bean>

<import resource="application-redis-context.xml" />

<import resource="application-mongoDB-context.xml" />

</beans>

redis.properties用法如下：

#最大分配的对象数  

jedisPool.maxActive=20  

 

#最大能够保持idel状态的对象数  

jedisPool.maxIdle=20  

 

#最小能够保持idel状态的对象数  

jedisPool.minIdle=10  

 

#当池内没有返回对象时，最大等待时间  

jedisPool.maxWait=-1  

 

#当调用borrow Object方法时，是否进行有效性检查  

#指明是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个

jedisPool.testOnBorrow=true  

  

#在return给pool时，是否提前进行validate操作

jedisPool.testOnReturn =false

 

#表示当pool中的jedis实例都被allocated完时，pool要采取的操作；

#默认有三种WHEN_EXHAUSTED_FAIL（表示无jedis实例时，直接抛出NoSuchElementException）、

#WHEN_EXHAUSTED_BLOCK（则表示阻塞住，或者达到maxWait时抛出JedisConnectionException）、

#WHEN_EXHAUSTED_GROW（则表示新建一个jedis实例，也就说设置的maxActive无用）

jedisPool.whenExhaustedAction=1 

 

#表示idle object evitor两次扫描之间要sleep的毫秒数；

jedisPool.timeBetweenEvictionRunsMillis = 100000

 

#如果为true，表示有一个idle object evitor线程对idle object进行扫描，如果validate失败，此object会被从pool中drop掉；

#这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义； 

jedisPool.testWhileIdle=true

 

#表示一个对象至少停留在idle状态的最短时间，然后才能被idle object evitor扫描并驱逐；

#这一项只有在timeBetweenEvictionRunsMillis大于0时才有意义

jedisPool.minEvictableIdleTimeMillis=300000 

 

#在minEvictableIdleTimeMillis基础上，加入了至少minIdle个对象已经在pool里面了。

#如果为-1，evicted不会根据idle time驱逐任何对象。如果minEvictableIdleTimeMillis>0，则此项设置无意义，

#且只有在timeBetweenEvictionRunsMillis大于0时才有意义

jedisPool.softMinEvictableIdleTimeMillis = -1 

 

#表示idle object evitor每次扫描的最多的对象数

jedisPool.numTestsPerEvictionRun = 50  

 

#borrowObject返回对象时，是采用DEFAULT_LIFO（last in first out，即类似cache的最频繁使用队列），如果为False，则表示FIFO队列

jedisPool.lifo = true

#IP  

jedisPool.shard1.host=127.0.0.1

#jedisPool.shard1.host=192.168.10.135

#jedisPool.shard1.host=139.196.6.164

#139.196.6.164

 

 

#Port  

jedisPool.shard1.port=6379

#jedisPool.shard1.port=2323

#jedisPool.shard1.port=32770

#32775

#

 

#password

jedisPool.shard1.password=test

 

#客户端超时时间单位是毫秒

redis.timeout=100000

 

#name

redis.name=queue

 

#database

redis.database=2

 

Titan_Framework
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
内部接口 java_java中的内部类内部接口用法说明
weixin_33665771的博客
02-12 505
简介一般来说，我们创建类和接口的时候都是一个类一个文件，一个接口一个文件，但有时候为了方便或者某些特殊的原因，java并不介意在一个文件中写多个类和多个接口，这就有了我们今天要讲的内部类和内部接口。内部类先讲内部类，内部类就是在类中定义的类。类中的类可以看做是类的一个属性，一个属性可以是static也可以是非static的。而内部类也可以定义在类的方法中，再加上匿名类，总共有5种内部类。静态内部类...
day09-附属-内部接口的介绍
MustangYL的博客
10-22 187
在接口中定义的接口就是内部接口。 内部接口默认使用public static 修饰，如果我们不写，系统也会自己加上。 Outer接口 public interface Outer { void outerMethod(); //public static final int num = 10; //public abstract void function(); interface Inner { void innerMetho...
内部类 匿名内部类 内部接口 对比说明
07-25
相关android开发中内部类 匿名内部类 内部接口 对比说明
为什么要使用内部类
Jack_Yin的专栏
07-12 110
为什么需要内部类？ java内部类有什么好处？为什么需要内部类？ 首先举一个简单的例子，如果你想实现一个接口，但是这个接口中的一个方法和你构想的这个类中的一个方法的名称，参数相同，你应该怎么办？这时候，你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的，所以这样做可以完成所有你直接实现这个接口的功能。 不过你可能要质疑，更改一下方法的不就行了吗？ 的确，以此作为设...
使用Titan Framework搭建一个集群Demo
Titan_Framework的博客
08-23 371
Titan Framework是一款分布式微服务框架，因其具有简单的配置方式，良好的集成性、多样化的支持、丰富的自定义扩展功能，所以它是非常值得我们去应用的。也正是因为它强大的集群特性，使得它在面对高负载，高并发的情况下表现得毫不逊色。本篇文章将介绍如何使用Titan Framework搭建一个集群的基本Demo。 1.Titan Framework依赖包下载 Titan Framework依...
docs:Titan Framework网站和文档
05-30
Titan Framework 是一个强大的开源框架，主要用于构建用户界面和管理配置。这个框架的网站不仅提供了框架的基本介绍，还包含了丰富的技术文档、在线书籍、互动论坛、教程以及实用技巧，旨在帮助开发者更好地理解和...
Titan-Framework, 最容易使用WordPress选项框架.zip
09-18
Titan-Framework, 最容易使用WordPress选项框架 泰坦框架 简单易用的WordPress选项框架。 Titan框架允许主题和插件开发者创建管理页面。选项。元框和主题定制选项，只需几个简单的代码行。把它放在WordPress插件的...
titan整合hadoop
08-16
2. **下载与解压Titan**：下载适用于Hadoop2的Titan版本，例如`titan-1.0.0-hadoop2`，解压到一个合适的目录。这个版本的Titan已经包含了对Hadoop2的适配。 3. **配置Titan**：在解压后的 Titan 配置目录下，修改`...
伊顿主令控制产品RMQ-Titan新型急停按钮 - 产品手册.PDF
09-14
伊顿主令控制产品RMQ-Titan新型急停按钮 - 产品手册PDF,M22的急停/紧急关断按钮的保护等级IP67、IP69K符合EN ISO 13850，防篡改，并符合欧洲和国际安全标准EN60204和IEC60204。具有UL/CSA认证。船舶行业中的德国劳氏...
伊顿主令控制产品RMQ-Titan新型急停按钮手册（英文）.PDF
09-13
伊顿主令控制产品RMQ-Titan新型急停按钮手册（英文）PDF,M22的急停/紧急关断按钮的保护等级IP67、IP69K符合EN ISO 13850，防篡改，并符合欧洲和国际安全标准EN60204和IEC60204。具有UL/CSA认证。船舶行业中的德国劳...
Titan Framework MongoDB深入理解2
Titan_Framework的博客
10-22 280
在上一篇文章中，我们提到了Titan框架集成的MongoDB功能内部一些比较重要的顶级接口，但我们平时接触到比较多的还是Curd和Finder这两个类，他们是Titan中对MongoDB直接操作的类，下面来对这两个类的方法进行一些讲解。 首先我们需要知道，我们用于存储的实体类必须对每一个属性进行注解映射，使用org.titan.framework.facade.annotations.Mappe...
Titan Framework Starter Guide
Titan_Framework的博客
06-27 346
介绍本文用来介绍Titan Framework，以及Titan Framework的简单使用。Titan Framework的描述Titan Framework是通过Actor模型使用响应式消息传输模式，提供具有高性能、高响应、高可伸缩和高韧性的并发应用框架。首先demo中有一个供外部调用的Controller接口，同时提供了一个调用其他微服务的handler方法，提供event方法接收微服务之间...
Titan Framework 项目部署
Titan_Framework的博客
06-28 964
介绍本文用来介绍Titan Framework的使用和下载， Titan Framework的多数据库支持，各个微服务之间的调用，微服务的配置与部署。Titan Framework依赖包的下载跟使用Titan Framework包可以做在Titan Framework PaaS平台上进行下载，提供各个版本。使用如下代码把Titan Framework 包加到本地maven仓库中：Echo move...
Titan Framework入门指南：添加可排序类型选项
代码教主
06-09 199
今天，我将讨论Titan框架中的sortable类型选项。 它为最终用户提供了许多选项，这些选项可以通过拖放界面重新排列，并且可以启用或禁用。 您可以在希望用户动态重新排列主题部分的地方集成此选项。 Titan Framework中的Sortable Type选项 如今，一些高级WordPress主题允许最终用户重新排列/排序主题中的不同块。 对于新开发人员而言，开发拖放式可排序界面可能是...
Titan Framework入门指南：添加代码类型选项
代码教主
06-09 251
有时，在构建插件或主题时，开发人员喜欢为最终用户提供添加自定义代码的能力。 今天，我将讨论如何在Titan框架中添加code类型选项，它使您可以创建一个可以在其中添加任何自定义代码的编辑器。 让我们来看看吧！ Titan Framework中的代码类型选项 在Titan框架中，可以通过其code类型选项创建用于输入代码的文本区域。 textarea支持语法突出显示，因此无论您使用哪种语言编...
Titan Framework入门指南：创建主题定制器部分
代码教主
06-10 178
在WordPress 3.4中添加的主题自定义API，允许开发人员自定义外观 ，并将控件添加到外观>自定义管理屏幕。 Titan Framework允许您扩展和使用大量字段/设置来基于Live Theme Customizer构建主题。 Titan框架是一个选项框架，仅需编写几行代码即可帮助创建多种类型的选项。 让我们看看如何通过Titan框架利用主题定制器选项。 基本设定 安...
计算机常见的内部接口,计算机内部接口大全！
weixin_30781567的博客
07-26 6597
主板是计算机的核心电路平台，作为计算机的骨干和中枢神经，担负着计算机各个硬件的调配及控制功能，其接口数量和复杂程度让很多不熟悉计算机的小伙伴表示看了就头疼。接下来就为大家盘点主板上的各个内部接口和安装方式，以后拆机或者更换硬件就不用担心把电脑拆坏了！一、CPU插槽CPU插槽一般位于主板的中心偏上位置，由多个接口点组成。CPU插槽的接口命名一般为：接口方式+接口数。例如LGA-2066，说明它是触点...
机器人通讯接口资料2016.pdf
05-24
在通讯接口方面，文档提到了KUKA的KRC4控制器，这是机器人与外部设备进行通信的核心。连接机器人和KRC4的电缆称为"Connecting cable Robot-KRC4"，标准配置为7米，但可选配15米到50米不等的延长电缆。此外，还提到了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值