语源科技BlogJava-java随记http://www.blogjava.net/fool/坚持就是胜利!zh-cnTue, 28 Apr 2026 18:59:41 GMTTue, 28 Apr 2026 18:59:41 GMT60DDD小结http://www.blogjava.net/fool/archive/2019/07/08/434108.html傻 瓜傻 瓜Mon, 08 Jul 2019 08:49:00 GMThttp://www.blogjava.net/fool/archive/2019/07/08/434108.htmlhttp://www.blogjava.net/fool/comments/434108.htmlhttp://www.blogjava.net/fool/archive/2019/07/08/434108.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/434108.htmlhttp://www.blogjava.net/fool/services/trackbacks/434108.html阅读全文

傻 瓜 2019-07-08 16:49 发表评论
]]>优秀代码赏析http://www.blogjava.net/fool/archive/2019/07/06/434083.html傻 瓜傻 瓜Sat, 06 Jul 2019 04:06:00 GMThttp://www.blogjava.net/fool/archive/2019/07/06/434083.htmlhttp://www.blogjava.net/fool/comments/434083.htmlhttp://www.blogjava.net/fool/archive/2019/07/06/434083.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/434083.htmlhttp://www.blogjava.net/fool/services/trackbacks/434083.html看开源的源代码，看到一个有意思的实现 。
/*
 * Copyright 2019 IBM All Rights Reserved.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
package org.hyperledger.fabric.gateway;
import org.hyperledger.fabric.gateway.impl.AllCommitStrategy;
import org.hyperledger.fabric.gateway.impl.AnyCommitStrategy;
import org.hyperledger.fabric.gateway.impl.CommitHandlerImpl;
import org.hyperledger.fabric.gateway.impl.CommitStrategy;
import org.hyperledger.fabric.gateway.impl.NoOpCommitHandler;
import org.hyperledger.fabric.gateway.spi.CommitHandler;
import org.hyperledger.fabric.gateway.spi.CommitHandlerFactory;
import org.hyperledger.fabric.sdk.Peer;
import org.hyperledger.fabric.sdk.exception.InvalidArgumentException;
import java.util.Collection;
/**
 * Default commit handler implementations. Instances can be referenced directly or looked up by name, for example
 * {@code DefaultCommitHandlers.valueOf("NONE")}.
 */
public enum DefaultCommitHandlers implements CommitHandlerFactory {
    /**
     * Do not wait for any commit events to be received from peers after submitting a transaction.
     */
    NONE((transactionId, network) -> NoOpCommitHandler.INSTANCE),
    /**
     * Wait to receive commit events from all currently responding peers in the user's organization after submitting
     * a transaction.
     */
    MSPID_SCOPE_ALLFORTX((transactionId, network) -> {
        Collection<Peer> peers = getPeersForOrganization(network);
        CommitStrategy strategy = new AllCommitStrategy(peers);
        CommitHandler handler = new CommitHandlerImpl(transactionId, network, strategy);
        return handler;
    }),
    /**
     * Wait to receive commit events from all currently responding peers in the network after submitting a transaction.
     */
    NETWORK_SCOPE_ALLFORTX((transactionId, network) -> {
        Collection<Peer> peers = network.getChannel().getPeers();
        CommitStrategy strategy = new AllCommitStrategy(peers);
        CommitHandler handler = new CommitHandlerImpl(transactionId, network, strategy);
        return handler;
    }),
    /**
     * Wait to receive a commit event from any currently responding peer in the user's organization after submitting
     * a transaction.
     */
    MSPID_SCOPE_ANYFORTX((transactionId, network) -> {
        Collection<Peer> peers = getPeersForOrganization(network);
        CommitStrategy strategy = new AnyCommitStrategy(peers);
        CommitHandler handler = new CommitHandlerImpl(transactionId, network, strategy);
        return handler;
    }),
    /**
     * Wait to receive a commit event from any currently responding peer in the network after submitting a transaction.
     */
    NETWORK_SCOPE_ANYFORTX((transactionId, network) -> {
        Collection<Peer> peers = network.getChannel().getPeers();
        CommitStrategy strategy = new AnyCommitStrategy(peers);
        CommitHandler handler = new CommitHandlerImpl(transactionId, network, strategy);
        return handler;
    });
    private final CommitHandlerFactory factory;
    DefaultCommitHandlers(CommitHandlerFactory factory) {
        this.factory = factory;
    }
    private static Collection<Peer> getPeersForOrganization(Network network) {
        String mspId = network.getGateway().getIdentity().getMspId();
        try {
            return network.getChannel().getPeersForOrganization(mspId);
        } catch (InvalidArgumentException e) {
            // This should never happen as mspId should not be null
            throw new RuntimeException(e);
        }
    }

   //CommitHandlerFactory 接口定义 的方法，这里是其实现 
    public CommitHandler create(String transactionId, Network network) {
        return factory.create(transactionId, network);
    }
}

先看看enum类的构造函数
    DefaultCommitHandlers(CommitHandlerFactory factory) {
        this.factory = factory;
    }
需要一个 CommitHandlerFactory 是个接口，同时 enum类本身也实现了这个接口。
再来看调用过程 
CommitHandlerFactory commitHandlerFactory = DefaultCommitHandlers.MSPID_SCOPE_ALLFORTX;
这里会调用CommitHandlerFactory 构造函数，其传入参数是
(transactionId, network) -> {
        Collection<Peer> peers = network.getChannel().getPeers();
        CommitStrategy strategy = new AllCommitStrategy(peers);
        CommitHandler handler = new CommitHandlerImpl(transactionId, network, strategy);
        return handler;
    }
它是lamdba写法，看看构造函数需要一个 CommitHandlerFactory 接口，这个lamdba 函数其实就是CommitHandlerFactory 的实现。
这样MSPID_SCOPE_ALLFORTX 枚举类型就有了一个  CommitHandlerFactory实现类的引用。

再看create调用。
CommitHandler commitHandler = commitHandlerFactory.create(transactionId, network);
这里enum类的create方法会执行， return factory.create(transactionId, network);
返回一个 CommitHandler .这里才会真正执行那个 lamdba定义的函数。
到这里只看到lamdb应用。。。
再分析一下create ,枚举类里的每个枚举变量都会实现一个这个方法。这里可以看到它其实是一个工厂类。
它创造的产品是CommitHandler ,其具体实现是CommitHandlerImpl类。
这里巧妙的使用一个enum当工厂类的实现。整个代码用了工厂模式加策略模式的实现。
优点：得宜于lamdb的应用，减少了具体工厂类的实现。
缺点：工厂模式可以实现不改动程序创建产品。那么这里如果要增一个产品，对这个enum类需要再添加一个枚举变量。
这个enum类有改动。




傻 瓜 2019-07-06 12:06 发表评论
]]>一个DDD示例代码http://www.blogjava.net/fool/archive/2019/06/27/433990.html傻 瓜傻 瓜Thu, 27 Jun 2019 09:09:00 GMThttp://www.blogjava.net/fool/archive/2019/06/27/433990.htmlhttp://www.blogjava.net/fool/comments/433990.htmlhttp://www.blogjava.net/fool/archive/2019/06/27/433990.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433990.htmlhttp://www.blogjava.net/fool/services/trackbacks/433990.htmlgithub上的一个java版的DDD实现的示例代码. 学习DDD时看一下还是不错的。
https://github.com/daoqidelv/community-ddd-demo.git
作者不是俺！

傻 瓜 2019-06-27 17:09 发表评论
]]>Fabric 1.1源代码分析(4) msp初始化过程http://www.blogjava.net/fool/archive/2018/06/25/433286.html傻 瓜傻 瓜Mon, 25 Jun 2018 01:00:00 GMThttp://www.blogjava.net/fool/archive/2018/06/25/433286.htmlhttp://www.blogjava.net/fool/comments/433286.htmlhttp://www.blogjava.net/fool/archive/2018/06/25/433286.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433286.htmlhttp://www.blogjava.net/fool/services/trackbacks/433286.html

 (MSP)是一个提供虚拟成员操作的管理框架的组件。
MSP抽取出签发和验证证书以及用户认证背后的所有加密机制和协议。 MSP可以定义自己的身份概念，以及这些身份管理的规则（身份验证）和身份验证（签名生成和验证）。

1、MSP接口定义
// MSP is the minimal Membership Service Provider Interface to be implemented
// to accommodate peer functionality
//最基本成员服务接口 其实现在mspimp.go文件中
type MSP interface {
// IdentityDeserializer interface needs to be implemented by MSP
IdentityDeserializer
// Setup the MSP instance according to configuration information
Setup(config *msp.MSPConfig) error
// GetVersion returns the version of this MSP
GetVersion() MSPVersion
// GetType returns the provider type
GetType() ProviderType
// GetIdentifier returns the provider identifier
GetIdentifier() (string, error)
// GetSigningIdentity returns a signing identity corresponding to the provided identifier
GetSigningIdentity(identifier *IdentityIdentifier) (SigningIdentity, error)
// GetDefaultSigningIdentity returns the default signing identity
GetDefaultSigningIdentity() (SigningIdentity, error)
// GetTLSRootCerts returns the TLS root certificates for this MSP
GetTLSRootCerts() [][]byte
// GetTLSIntermediateCerts returns the TLS intermediate root certificates for this MSP
GetTLSIntermediateCerts() [][]byte
// Validate checks whether the supplied identity is valid
Validate(id Identity) error
// SatisfiesPrincipal checks whether the identity matches
// the description supplied in MSPPrincipal. The check may
// involve a byte-by-byte comparison (if the principal is
// a serialized identity) or may require MSP validation
SatisfiesPrincipal(id Identity, principal *msp.MSPPrincipal) error
}
2、 BCCSP接口定义 BCCSP是加、解密及签名服务。 bccp.go文件中默认实现是sw/impl.go .
支持ecdsa、rsa以及aes算法 BCCSP的实现包括:
1,[sw]目录为the software-based implementation of the BCCSP，即基于软件的BCCSP实现，通过调用go原生支持的密码算法实现，并提供keystore来保存密钥
2,[pkcs11]目录，为bccsp的pkcs11实现，通过调用pkcs11接口实现相关加密操作，，密码保存在pkcs11通过pin口令保护的数据库或者硬件设备中。
type BCCSP interface {
    KeyGen(opts KeyGenOpts) (k Key, err error) //生成Key
    KeyDeriv(k Key, opts KeyDerivOpts) (dk Key, err error) //派生Key
    KeyImport(raw interface{}, opts KeyImportOpts) (k Key, err error) //导入Key
    GetKey(ski []byte) (k Key, err error) //获取Key
    Hash(msg []byte, opts HashOpts) (hash []byte, err error) //哈希msg
    GetHash(opts HashOpts) (h hash.Hash, err error) //获取哈希实例
    Sign(k Key, digest []byte, opts SignerOpts) (signature []byte, err error) //签名
    Verify(k Key, signature, digest []byte, opts SignerOpts) (valid bool, err error) //校验签名
    Encrypt(k Key, plaintext []byte, opts EncrypterOpts) (ciphertext []byte, err error) //加密
    Decrypt(k Key, ciphertext []byte, opts DecrypterOpts) (plaintext []byte, err error) //解密
}
//代码在bccsp/bccsp.go
3、KeyStore接口（密钥存储）定义如下： 其实现是bccsp/sw/fileks.go
type KeyStore interface {
    ReadOnly() bool //密钥库是否只读，只读时StoreKey将失败
    GetKey(ski []byte) (k Key, err error) //如果SKI通过，返回Key.从相关文件中加载 
　　StoreKey(k Key) (err error) //将Key存储到密钥库中 sw实现是写入相关文件
}
//代码在bccsp/keystore.go
bccsp/sw/fileks.go中 StoreKey的实现 可见相关key写入文件
func (ks *fileBasedKeyStore) StoreKey(k bccsp.Key) (err error) {
if ks.readOnly {
return errors.New("Read only KeyStore.")
}
if k == nil {
return errors.New("Invalid key. It must be different from nil.")
}
switch k.(type) {
case *ecdsaPrivateKey:
kk := k.(*ecdsaPrivateKey)
err = ks.storePrivateKey(hex.EncodeToString(k.SKI()), kk.privKey)
if err != nil {
return fmt.Errorf("Failed storing ECDSA private key [%s]", err)
}
case *ecdsaPublicKey:
kk := k.(*ecdsaPublicKey)
err = ks.storePublicKey(hex.EncodeToString(k.SKI()), kk.pubKey)
if err != nil {
return fmt.Errorf("Failed storing ECDSA public key [%s]", err)
}
case *rsaPrivateKey:
kk := k.(*rsaPrivateKey)
err = ks.storePrivateKey(hex.EncodeToString(k.SKI()), kk.privKey)
if err != nil {
return fmt.Errorf("Failed storing RSA private key [%s]", err)
}
case *rsaPublicKey:
kk := k.(*rsaPublicKey)
err = ks.storePublicKey(hex.EncodeToString(k.SKI()), kk.pubKey)
if err != nil {
return fmt.Errorf("Failed storing RSA public key [%s]", err)
}
case *aesPrivateKey:
kk := k.(*aesPrivateKey)
err = ks.storeKey(hex.EncodeToString(k.SKI()), kk.privKey)
if err != nil {
return fmt.Errorf("Failed storing AES key [%s]", err)
}
4、mspconfig的初始化流程图
其中getMspConfig方法比较重要.也一目了然，加载相关证书存入byte[].最终串行化成json
func getMspConfig(dir string, ID string, sigid *msp.SigningIdentityInfo) (*msp.MSPConfig, error) {
///data/config/hyperledger/fabric/crypto-config/peerOrganizations/org1.ygsoft.com/peers/peer0.org1.ygsoft.com/msp/cacerts
cacertDir := filepath.Join(dir, cacerts)
///data/config/hyperledger/fabric/crypto-config/peerOrganizations/org1.ygsoft.com/peers/peer0.org1.ygsoft.com/msp/admincerts
admincertDir := filepath.Join(dir, admincerts)
// //data/config/hyperledger/fabric/crypto-config/peerOrganizations/org1.ygsoft.com/peers/peer0.org1.ygsoft.com/msp/ntermediatecerts
intermediatecertsDir := filepath.Join(dir, intermediatecerts)
///data/config/hyperledger/fabric/crypto-config/peerOrganizations/org1.ygsoft.com/peers/peer0.org1.ygsoft.com/msp/crls
crlsDir := filepath.Join(dir, crlsfolder)
configFile := filepath.Join(dir, configfilename)
///data/config/hyperledger/fabric/crypto-config/peerOrganizations/org1.ygsoft.com/peers/peer0.org1.ygsoft.com/msp/tlscacerts
tlscacertDir := filepath.Join(dir, tlscacerts)
tlsintermediatecertsDir := filepath.Join(dir, tlsintermediatecerts)
cacerts, err := getPemMaterialFromDir(cacertDir)
if err != nil || len(cacerts) == 0 {
return nil, errors.WithMessage(err, fmt.Sprintf("could not load a valid ca certificate from directory %s", cacertDir))
}
admincert, err := getPemMaterialFromDir(admincertDir)
if err != nil || len(admincert) == 0 {
return nil, errors.WithMessage(err, fmt.Sprintf("could not load a valid admin certificate from directory %s", admincertDir))
}
intermediatecerts, err := getPemMaterialFromDir(intermediatecertsDir)
if os.IsNotExist(err) {
mspLogger.Debugf("Intermediate certs folder not found at [%s]. Skipping. [%s]", intermediatecertsDir, err)
} else if err != nil {
return nil, errors.WithMessage(err, fmt.Sprintf("failed loading intermediate ca certs at [%s]", intermediatecertsDir))
}
tlsCACerts, err := getPemMaterialFromDir(tlscacertDir)
tlsIntermediateCerts := [][]byte{}
if os.IsNotExist(err) {
mspLogger.Debugf("TLS CA certs folder not found at [%s]. Skipping and ignoring TLS intermediate CA folder. [%s]", tlsintermediatecertsDir, err)
} else if err != nil {
return nil, errors.WithMessage(err, fmt.Sprintf("failed loading TLS ca certs at [%s]", tlsintermediatecertsDir))
} else if len(tlsCACerts) != 0 {
tlsIntermediateCerts, err = getPemMaterialFromDir(tlsintermediatecertsDir)
if os.IsNotExist(err) {
mspLogger.Debugf("TLS intermediate certs folder not found at [%s]. Skipping. [%s]", tlsintermediatecertsDir, err)
} else if err != nil {
return nil, errors.WithMessage(err, fmt.Sprintf("failed loading TLS intermediate ca certs at [%s]", tlsintermediatecertsDir))
}
} else {
mspLogger.Debugf("TLS CA certs folder at [%s] is empty. Skipping.", tlsintermediatecertsDir)
}
crls, err := getPemMaterialFromDir(crlsDir)
if os.IsNotExist(err) {
mspLogger.Debugf("crls folder not found at [%s]. Skipping. [%s]", crlsDir, err)
} else if err != nil {
return nil, errors.WithMessage(err, fmt.Sprintf("failed loading crls at [%s]", crlsDir))
}
// Load configuration file
// if the configuration file is there then load it
// otherwise skip it
//加载配置文件  ../msp/config.yaml 存在就加载，不存在就跳过
var ouis []*msp.FabricOUIdentifier
var nodeOUs *msp.FabricNodeOUs
_, err = os.Stat(configFile)
if err == nil {
// load the file, if there is a failure in loading it then
// return an error
raw, err := ioutil.ReadFile(configFile)
if err != nil {
return nil, errors.Wrapf(err, "failed loading configuration file at [%s]", configFile)
}
configuration := Configuration{}
err = yaml.Unmarshal(raw, &configuration)
if err != nil {
return nil, errors.Wrapf(err, "failed unmarshalling configuration file at [%s]", configFile)
}
// Prepare OrganizationalUnitIdentifiers
if len(configuration.OrganizationalUnitIdentifiers) > 0 {
for _, ouID := range configuration.OrganizationalUnitIdentifiers {
f := filepath.Join(dir, ouID.Certificate)
raw, err = readFile(f)
if err != nil {
return nil, errors.Wrapf(err, "failed loading OrganizationalUnit certificate at [%s]", f)
}
oui := &msp.FabricOUIdentifier{
Certificate:                  raw,
OrganizationalUnitIdentifier: ouID.OrganizationalUnitIdentifier,
}
ouis = append(ouis, oui)
}
}
// Prepare NodeOUs
if configuration.NodeOUs != nil && configuration.NodeOUs.Enable {
mspLogger.Info("Loading NodeOUs")
if configuration.NodeOUs.ClientOUIdentifier == nil || len(configuration.NodeOUs.ClientOUIdentifier.OrganizationalUnitIdentifier) == 0 {
return nil, errors.New("Failed loading NodeOUs. ClientOU must be different from nil.")
}
if configuration.NodeOUs.PeerOUIdentifier == nil || len(configuration.NodeOUs.PeerOUIdentifier.OrganizationalUnitIdentifier) == 0 {
return nil, errors.New("Failed loading NodeOUs. PeerOU must be different from nil.")
}
nodeOUs = &msp.FabricNodeOUs{
Enable:             configuration.NodeOUs.Enable,
ClientOUIdentifier: &msp.FabricOUIdentifier{OrganizationalUnitIdentifier: configuration.NodeOUs.ClientOUIdentifier.OrganizationalUnitIdentifier},
PeerOUIdentifier:   &msp.FabricOUIdentifier{OrganizationalUnitIdentifier: configuration.NodeOUs.PeerOUIdentifier.OrganizationalUnitIdentifier},
}
// Read certificates, if defined
// ClientOU
f := filepath.Join(dir, configuration.NodeOUs.ClientOUIdentifier.Certificate)
raw, err = readFile(f)
if err != nil {
mspLogger.Infof("Failed loading ClientOU certificate at [%s]: [%s]", f, err)
} else {
nodeOUs.ClientOUIdentifier.Certificate = raw
}
// PeerOU
f = filepath.Join(dir, configuration.NodeOUs.PeerOUIdentifier.Certificate)
raw, err = readFile(f)
if err != nil {
mspLogger.Debugf("Failed loading PeerOU certificate at [%s]: [%s]", f, err)
} else {
nodeOUs.PeerOUIdentifier.Certificate = raw
}
}
} else {
mspLogger.Debugf("MSP configuration file not found at [%s]: [%s]", configFile, err)
}
// Set FabricCryptoConfig
cryptoConfig := &msp.FabricCryptoConfig{
SignatureHashFamily:            bccsp.SHA2,
IdentityIdentifierHashFunction: bccsp.SHA256,
}
// Compose FabricMSPConfig
fmspconf := &msp.FabricMSPConfig{
Admins:            admincert,
RootCerts:         cacerts,
IntermediateCerts: intermediatecerts,
SigningIdentity:   sigid,
Name:              ID,
OrganizationalUnitIdentifiers: ouis,
RevocationList:                crls,
CryptoConfig:                  cryptoConfig,
TlsRootCerts:                  tlsCACerts,
TlsIntermediateCerts:          tlsIntermediateCerts,
FabricNodeOUs:                 nodeOUs,
}
    //串行化成json格式的byte[] 
fmpsjs, _ := proto.Marshal(fmspconf)
 
//MSPConfig的msp_config.pb.go文件中定义 
    //type MSPConfig struct {
//Type int32 `protobuf:"varint,1,opt,name=type" json:"type,omitempty"`
//Config []byte `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"`
    //}
mspconf := &msp.MSPConfig{Config: fmpsjs, Type: int32(FABRIC)}
return mspconf, nil
msp/mspimplsetup.go文件中根据上面生成的mspconf对证书进行了相关设置,结果保存
在/mspimpl.go中的结体bccspmsp中
func (msp *bccspmsp) preSetupV1(conf *m.FabricMSPConfig) error {
// setup crypto config
if err := msp.setupCrypto(conf); err != nil {
return err
}
// Setup CAs  //设置ca证书，中间证书等，涉及到x509包。并构建相关identity类。
//根据证书内容加hash后生成identity类
if err := msp.setupCAs(conf); err != nil {
return err
}
// Setup Admins
if err := msp.setupAdmins(conf); err != nil {
return err
}
// Setup CRLs
if err := msp.setupCRLs(conf); err != nil {
return err
}
// Finalize setup of the CAs
if err := msp.finalizeSetupCAs(conf); err != nil {
return err
}
// setup the signer (if present)
if err := msp.setupSigningIdentity(conf); err != nil {
return err
}
// setup TLS CAs
if err := msp.setupTLSCAs(conf); err != nil {
return err
}
// setup the OUs
if err := msp.setupOUs(conf); err != nil {
return err
}
return nil
}


傻 瓜 2018-06-25 09:00 发表评论
]]> Fabric 1.1源代码分析(3) 系统链码执行过程示例(弟弟篇）http://www.blogjava.net/fool/archive/2018/06/13/433279.html傻 瓜傻 瓜Wed, 13 Jun 2018 06:37:00 GMThttp://www.blogjava.net/fool/archive/2018/06/13/433279.htmlhttp://www.blogjava.net/fool/comments/433279.htmlhttp://www.blogjava.net/fool/archive/2018/06/13/433279.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433279.htmlhttp://www.blogjava.net/fool/services/trackbacks/433279.html
# Fabric 1.1源代码分析(3) 系统链码执行过程
## 1、系统链码执行过程
* 以peer channel join -b gensis.block命令为例。该命令结果是peer节点加入通道.
这个命令会单独启一个进程.在该进程中会构建一个名称为cscc的链码消息传到peer节点.
通过grpc调用最终会进到endorser.go中的ProcessProposal函数进行处理。
参考Fabric 1.1源代码分析(2)http://www.blogjava.net/fool/archive/2018/06/12/433277.html
系统链码初始化过程,可以找到../shim/handler.go中
的handleTransaction()函数.最终会调用res := handler.cc.Invoke(stub).这里的
cc就是importsysccs.go文件中systemChaincodes数组中的cscc系统链码的.    
Chaincode,其实例是&cscc.PeerConfiger{},实现在cscc/configure.go文件中。每个系统
链码都实现了这个Chaincode接口()
```go
type Chaincode interface {
    // Init is called during Instantiate transaction after the chaincode container
    // has been established for the first time, allowing the chaincode to
    // initialize its internal data
    Init(stub ChaincodeStubInterface) pb.Response

    // Invoke is called to update or query the ledger in a proposal transaction.
    // Updated state variables are not committed to the ledger until the
    // transaction is committed.
    Invoke(stub ChaincodeStubInterface) pb.Response
}
```

* 至此就可以清晰地看到每一个系统链码都会启动一对协程，通过chan通信。系统链码消息由
shim/handler.go中的函数处理.并且这里最终调用各自的具体实现的Ivoke方法进行业务处理

## 2、peer channel join命令处理流程图
* peer channel join命令会调用configure.go中的Excute方法。对应cscc系统链码的处理，
原因如下，以下流程图大致可以了解cscc都做了些什么
![](cscc.png)

## 3、小结

* 上面的流程图也不是非常地强细，忽略掉了一些方法。但是有了整个流程的理解，就能理解其
它系统链码的调用过程，需要时直接细读其实现就好了。从上流程图中可以看到文件末尾添加区
区块，leveldb中记录了区块号，索引位置信息等等。另外因为系统链码跟一般链码虽然经过
的文件基本一样，但最终处理方式还是不一样，一个是协程，一个是grpc.可能参考Fabric 1.1
源代码分析之 Chaincode（链码）初始化 http://www.blogjava.net/fool/archive/2018/06/12/433275.html


傻 瓜 2018-06-13 14:37 发表评论
]]>Fabric 1.1源代码分析之 系统链码初始化过程(哥哥篇)http://www.blogjava.net/fool/archive/2018/06/12/433277.html傻 瓜傻 瓜Tue, 12 Jun 2018 07:00:00 GMThttp://www.blogjava.net/fool/archive/2018/06/12/433277.htmlhttp://www.blogjava.net/fool/comments/433277.htmlhttp://www.blogjava.net/fool/archive/2018/06/12/433277.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433277.htmlhttp://www.blogjava.net/fool/services/trackbacks/433277.html
# Fabric 1.1源代码分析之 Fabric 1.1源代码分析 系统链码初始化过程

* 链码这一块的代码非常的绕。基本上就是一个大循环。限于水平或者其它原因，差露可能难免，各位看官包涵则个...

## 1、系统链码

* 系统链码跟智能合约链码涉及到的文件差不多，流程也差不多。只是智能合约是grpc,系统链码是chan实现调用.
LSCC Lifecycle system chaincode，处理生命周期请求。我理解的生命周期请求应该指的是一个chaincode的安装，实例化，升级，
卸载等对其生命周期起关键作用的一系列操作请求。
CSCC Configuration system chaincode，处理在peer程序端的channel配置。
QSCC Query system chaincode，提供账本查询接口，如获取块和交易信息。
ESCC Endorsement system chaincode，通过对交易申请的应答信息进行签名，来提供背书功能。
VSCC Validation system chaincode，处理交易校验，包括检查背书策略和版本在并发时的控制。

## 2、系统链码注册
* 在/core/chaincode/shim/interfaces_stable.go中实现了下面的接口
```go
type Chaincode interface {
    // Init is called during Instantiate transaction after the chaincode container
    // has been established for the first time, allowing the chaincode to
    // initialize its internal data
    Init(stub ChaincodeStubInterface) pb.Response

    // Invoke is called to update or query the ledger in a proposal transaction.
    // Updated state variables are not committed to the ledger until the
    // transaction is committed.
    Invoke(stub ChaincodeStubInterface) pb.Response
}
```

* 在core/scc/sysccapi.go中定义了SystemChaincode结构体，其中定义了 Chaincode接口变量
```go
type SystemChaincode struct {
    //Unique name of the system chaincode
    Name string

    //Path to the system chaincode; currently not used
    Path string

    //InitArgs initialization arguments to startup the system chaincode
    InitArgs [][]byte

    // Chaincode is the actual chaincode object
    Chaincode shim.Chaincode

    // InvokableExternal keeps track of whether
    // this system chaincode can be invoked
    // through a proposal sent to this peer
    InvokableExternal bool

    // InvokableCC2CC keeps track of whether
    // this system chaincode can be invoked
    // by way of a chaincode-to-chaincode
    // invocation
    InvokableCC2CC bool

    // Enabled a convenient switch to enable/disable system chaincode without
    // having to remove entry from importsysccs.go
    Enabled bool
}
```

* 在 core/scc/importsysccs.go文件中对系统链码进行了初始化，并且每个Chainoce指定了具体实现
在
```go
//see systemchaincode_test.go for an example using "sample_syscc"
var systemChaincodes = []*SystemChaincode{
    {
        Enabled: true,
        Name: "cscc",
        Path: "github.com/hyperledger/fabric/core/scc/cscc",
        InitArgs: [][]byte{[]byte("")},
        Chaincode: &cscc.PeerConfiger{},
        InvokableExternal: true, // cscc is invoked to join a channel
    },
    {
        Enabled: true,
        Name: "lscc",
        Path: "github.com/hyperledger/fabric/core/scc/lscc",
        InitArgs: [][]byte{[]byte("")},
        Chaincode: lscc.NewLifeCycleSysCC(),
        InvokableExternal: true, // lscc is invoked to deploy new chaincodes
        InvokableCC2CC: true, // lscc can be invoked by other chaincodes
    },
    {
        Enabled: true,
        Name: "escc",
        Path: "github.com/hyperledger/fabric/core/scc/escc",
        InitArgs: [][]byte{[]byte("")},
        Chaincode: &escc.EndorserOneValidSignature{},
    },
    {
        Enabled: true,
        Name: "vscc",
        Path: "github.com/hyperledger/fabric/core/scc/vscc",
        InitArgs: [][]byte{[]byte("")},
        Chaincode: &vscc.ValidatorOneValidSignature{},
    },
    {
        Enabled: true,
        Name: "qscc",
        Path: "github.com/hyperledger/fabric/core/chaincode/qscc",
        InitArgs: [][]byte{[]byte("")},
        Chaincode: &qscc.LedgerQuerier{},
        InvokableExternal: true, // qscc can be invoked to retrieve blocks
        InvokableCC2CC: true, // qscc can be invoked to retrieve blocks also by a cc
    },
}
```
* 注册流程图
![](systemcoderegist.png)


## 3、系统链码初始化
* 系统注册完成后会对链码初始化.跟一般chaincode稍有不同的是chaincode在合约里通过grpc与peer节点交互。
而系统链码则是在协程里通过chan 实现交互.下面代码创建两个 peerRcvCCSend := make(chan *pb.ChaincodeMessage)
    ccRcvPeerSend := make(chan *pb.ChaincodeMessage) ，是客户端和服务端共同的参数
```go

func (ipc *inprocContainer) launchInProc(ctxt context.Context, id string, args []string, env []string, ccSupport ccintf.CCSupport) error {
    peerRcvCCSend := make(chan *pb.ChaincodeMessage)
    ccRcvPeerSend := make(chan *pb.ChaincodeMessage)
    var err error
    ccchan := make(chan struct{}, 1)
    ccsupportchan := make(chan struct{}, 1)
    //启动客户端处理
    go func() {
        defer close(ccchan)
        inprocLogger.Debugf("chaincode started for %s", id)
        if args == nil {
            args = ipc.args
        }
        if env == nil {
            env = ipc.env
        }
        err := _shimStartInProc(env, args, ipc.chaincode, ccRcvPeerSend, peerRcvCCSend)
        if err != nil {
            err = fmt.Errorf("chaincode-support ended with err: %s", err)
            _inprocLoggerErrorf("%s", err)
        }
        inprocLogger.Debugf("chaincode ended with for %s with err: %s", id, err)
    }()
//启动服务端处理
    go func() {
        defer close(ccsupportchan)
        inprocStream := newInProcStream(peerRcvCCSend, ccRcvPeerSend)
        inprocLogger.Debugf("chaincode-support started for %s", id)
        err := ccSupport.HandleChaincodeStream(ctxt, inprocStream)
        if err != nil {
            err = fmt.Errorf("chaincode ended with err: %s", err)
            _inprocLoggerErrorf("%s", err)
        }
        inprocLogger.Debugf("chaincode-support ended with for %s with err: %s", id, err)
    }()

    select {
    case <-ccchan:
        close(peerRcvCCSend)
        inprocLogger.Debugf("chaincode %s quit", id)
    case <-ccsupportchan:
        close(ccRcvPeerSend)
        inprocLogger.Debugf("chaincode support %s quit", id)
    case <-ipc.stopChan:
        close(ccRcvPeerSend)
        close(peerRcvCCSend)
        inprocLogger.Debugf("chaincode %s stopped", id)
    }
    return err
}

```


* 初始化流程图
![](systemcodeinit.png)


## 4、系统链码的执行
...


傻 瓜 2018-06-12 15:00 发表评论
]]>Fabric 1.1源代码分析之 Chaincode（链码）初始化http://www.blogjava.net/fool/archive/2018/06/12/433275.html傻 瓜傻 瓜Tue, 12 Jun 2018 06:51:00 GMThttp://www.blogjava.net/fool/archive/2018/06/12/433275.htmlhttp://www.blogjava.net/fool/comments/433275.htmlhttp://www.blogjava.net/fool/archive/2018/06/12/433275.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433275.htmlhttp://www.blogjava.net/fool/services/trackbacks/433275.html阅读全文

傻 瓜 2018-06-12 14:51 发表评论
]]>开源区块链Hyperleger Fabric之链码开发调试模式在IDE里debug链码http://www.blogjava.net/fool/archive/2018/05/23/433231.html傻 瓜傻 瓜Wed, 23 May 2018 06:17:00 GMThttp://www.blogjava.net/fool/archive/2018/05/23/433231.htmlhttp://www.blogjava.net/fool/comments/433231.htmlhttp://www.blogjava.net/fool/archive/2018/05/23/433231.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433231.htmlhttp://www.blogjava.net/fool/services/trackbacks/433231.html1,启动order
    orderer start
2, 使用开发模式启动peer节点
   peer node start --peer-chaincodedev=true
3,创建通道
4,启动链码程序
这一步可以在IDE里启动链码，这样就可以debug了
cd examples/chaincode/go/chaincode_example02
go build
CORE_CHAINCODE_LOGLEVEL=debug CORE_PEER_ADDRESS=127.0.0.1:7052 CORE_CHAINCODE_ID_NAME=mycc:0 ./chaincode_example02
5,安装链码
peer chaincode install -n mycc -v 0 -p github.com/hyperledger/fabric/examples/chaincode/go/chaincode_example02
6,初始化链码
peer chaincode instantiate -n mycc -v 0 -c '{"Args":["init","a","100","b","200"]}' -o 127.0.0.1:7050 -C ch1
7,链码调用和测试


傻 瓜 2018-05-23 14:17 发表评论
]]>开源区块链Hyperleger Fabric之通过Composer开发框架快速搭建开发环境http://www.blogjava.net/fool/archive/2018/03/12/433093.html傻 瓜傻 瓜Mon, 12 Mar 2018 08:44:00 GMThttp://www.blogjava.net/fool/archive/2018/03/12/433093.htmlhttp://www.blogjava.net/fool/comments/433093.htmlhttp://www.blogjava.net/fool/archive/2018/03/12/433093.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433093.htmlhttp://www.blogjava.net/fool/services/trackbacks/433093.html
准备工作：(自行百度）

开发环境必备软件：

 composer-cli

 generator-hyperledger-composr

composer-rest-server
Yeoman

安装playground

 

Installing and running Hyperledger Composer Playground locally
docker ps -aq | xargs docker rm -f
docker images -aq | xargs docker rmi -f
curl -sSL https://hyperledger.github.io/composer/install-hlfv1.sh | bash   
执行install-hlfv1.sh 安装运行fabric1.06版.并运行 playground服务 打开流览器http://xxxx:8080显示如下



1,playground 的Web Browser区域提供了在页面定义模型、测试模型的能力。并不保存。但可以导出bna文件

2,connection区域提供了在开发环境布署合约，会生成一个智能合约的docker运行环境.
 3,可以在上图中上部分的My Business Networks 工作区点击虚业部分Deploy a new business network

4，在接下来页面中选中一个示例。如 marble neetworkd.  选择 ID and Secret 填入admin 和 adminpw

5，点击Deploy按钮后会发布一个合约.并跳到测试页如下图:



6，在上图中 Test Tab页可以进行测试 ,在Define Tab页可以导出bna文件.
7,在第一幅图中点击下载按钮，会下载一个 .card文件，描述了连接fabric peer节点等相关连接信息.记得要导 PeerAdmin@hlfv1的card和你自己测试用的card,及bna文件
8,分别执行  composer card import -f PeerAdmin.card  ，composer card import -f admin.card  .composer card list 可以查看你导入的card的name信息.

       9,composer-rest-server -c admin@empty-business-network -n always -w true  启动rest服务默认端口3000.

      10,好了,可以体验一下fabric是个什么玩意了。：） 88!




傻 瓜 2018-03-12 16:44 发表评论
]]>开源区块链Hyperleger Fabric通过SDK-JAVA动态添加通道http://www.blogjava.net/fool/archive/2018/03/12/433090.html傻 瓜傻 瓜Mon, 12 Mar 2018 03:55:00 GMThttp://www.blogjava.net/fool/archive/2018/03/12/433090.htmlhttp://www.blogjava.net/fool/comments/433090.htmlhttp://www.blogjava.net/fool/archive/2018/03/12/433090.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433090.htmlhttp://www.blogjava.net/fool/services/trackbacks/433090.html
在阅读本篇之前需要理解
configtxgen工具使用原理.基本上能跑通
开源区块链Hyperleger Fabric的SDK-JAVA新手上路指引
中的内容。可以参考http://www.blogjava.net/fool/archive/2018/02/01/433032.html.
如果知道通过命令行工具进行智能合约的安装测试就更好了。fabric中的channel可以理解为泳道。在这个泳道中可以布署
多个智能合约。当然也可以安装多个channel. 顺便多一嘴，在智能合约可以调用另一个channel中的智能合约中的查询方法.
通过sdk动态安装通道的步骤：
1,通过configtxgen命令生成交易通道初始文件.
configtxgen --profile TestSoft --outputCreateChannelTx testsoft.tx --channelID testsoft
2,下载testsoft.tx到本机.
3,sdk安装通道代码及解释
@Override
public boolean installChannel(String channelName) throws IOException, InvalidArgumentException, TransactionException, ProposalException {
// TODO Auto-generated method stub
 String configPath = this.config.getConfigPath();
                         //初始化 ChannelConfiguration 对象.参数是通道初始化文件路径
 ChannelConfiguration channelConfiguration = new ChannelConfiguration(new File(configPath + "/"+channelName + ".tx"));
  //构造orderder节点信息
   String ordererName = orderers.get().get(0).getOrdererName();
Properties ordererProperties = loadOrderProperty(ordererName);
Orderer anOrderer = client.newOrderer(
ordererName,
orderers.get().get(0).getOrdererLocation(), ordererProperties);
       //Create channel that has only one signer that is this orgs peer admin. If channel creation policy needed more signature they would need to be added too.
       Channel channel = client.newChannel(channelName, anOrderer, channelConfiguration, client.getChannelConfigurationSignature(channelConfiguration, fabricOrg.getPeerAdmin()));
                       //构造peer节点信息，并且将peer节点加入到通道中。peer节点加入通道后，才能通过该peer节点中访问通道中的智能合约
       for (com.ygsoft.fabric.bean.Peers.Peer p : config.getInstallPeers().get()) {
Properties peerProperties = this.loadPeerProperties(p.getPeerName());
Peer peer = client.newPeer(p.getPeerName(),p.getPeerLocation(),peerProperties);
channel.joinPeer(peer);
}
for (int i = 0; i < orderers.get().size(); i++) {
Properties ordererProperties2 = loadOrderProperty(ordererName);
channel.addOrderer(client.newOrderer(
orderers.get().get(i).getOrdererName(),
orderers.get().get(i)
.getOrdererLocation(), ordererProperties2));
}
log.debug("channel.isInitialized() = " + channel.isInitialized());
  channel.initialize();
 return true;
}

知道了手工命令行安装合约的过程，上面的理解还是比较简单的。安装通道后就可以调用sdk安装合约了。













傻 瓜 2018-03-12 11:55 发表评论
]]>开源区块链Hyperleger Fabric的SDK-JAVA新手上路指引http://www.blogjava.net/fool/archive/2018/02/01/433032.html傻 瓜傻 瓜Thu, 01 Feb 2018 01:03:00 GMThttp://www.blogjava.net/fool/archive/2018/02/01/433032.htmlhttp://www.blogjava.net/fool/comments/433032.htmlhttp://www.blogjava.net/fool/archive/2018/02/01/433032.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/433032.htmlhttp://www.blogjava.net/fool/services/trackbacks/433032.html区块链工程师。不久抱得美人归。:)

阅读本代码前，先看看fabric的多机布署,参考下面的贴子1:
http://blog.csdn.net/songbin830/article/details/78778806 完成多机布署.

参考贴子2: http://www.cnblogs.com/aberic/p/8206551.html ，把代码下到本地工程里。新手上路总会遇到
各种细节问题.重点来了：

使用git命令从github.com上拉下SDK-JAVA源码.
1，源码文件中有EclipseSetup.md的文件，介绍如何把源码项目导入eclipse.
2，导入eclipse后发现缺少  org.hyperledger.fabric.protos.*文件。github上的源码里也没有。解决办法：从
其它网站的 SDK-JAVA打包文件中找到源码包，把org.hyperledger.fabric.protos包中的源码copy到eclipse。
3，在orderer节点把  crypto-config文件夹中的内容copy到本机.其中包含了用命令工具生成的证书，身份信息
等内容
4,贴子2中代码如何用，其实跟源码中的测试用例中的代码差不多.初始化示例如下：因为贴子2是个demo类代码，
我作了些改动。有些代码没放ChaincodeManager()实例化。看一下这个类的构造方法，构造对应的需要的实例类
也不难

public static ChaincodeManager init() throws Exception{
FabricConfig fabricConfig = new FabricConfig("E:/fabricConfig");  //fabricConfig文件夹中包含
                //crypto-config文件夹
Peers peers = new Peers();   //初始化peer节点
peers.setOrgDomainName("org1.ygsoft.com");
peers.setOrgMSPID("Org1MSP");
peers.setOrgName("Org1MSP");
//peers.addPeer("peer0.org1.ygsoft.com", "peer0.org1.ygsoft.com", "grpcs://10.121.60.2:7051", "grpcs://10.121.60.2:7053", null);
peers.addPeer("peer1.org1.ygsoft.com", "peer1.org1.ygsoft.com", "grpcs://10.121.60.3:7051", "grpcs://10.121.60.3:7053", null);
fabricConfig.setPeers(peers);
//初始化orderer节点
Orderers orders = new Orderers();
orders.setOrdererDomainName("ygsoft.com");
orders.addOrderer("orderer.ygsoft.com", "grpcs://10.121.60.1:7050");
fabricConfig.setOrderers(orders);
fabricConfig.setRegisterEvent(true);
ChaincodeManager chainManager = new ChaincodeManager(fabricConfig);
return chainManager;
}

5,其它参数，比如chaincode相关信息可以在peer节点  peer chaincode list --installed 命令可以查看
可以调用这个ChaincodeManager 的query和invoke方法了.

6,补充内容:需要shim-client.jar包，这个需要拉下fabric的源码，在文件夹
\src\github.com\hyperledger\fabric\core\chaincode\shim\java 用gradle编译一个jar包出来

7，如果grpc用了ssl的需要 grpcs://10.121.60.3:7051，grpcs开头

因为网上有了fabric多机布署教程,和不完善的示例代码，这里主要介绍一下其中容易遇到的问题，解决起
来也颇为头痛和费时。
本贴原地址:http://www.blogjava.net/fool .下一篇区块链贴子预告：Fabric的SDK-JAVA动态安装
Channel













傻 瓜 2018-02-01 09:03 发表评论
]]>springCloud、boot集成elkhttp://www.blogjava.net/fool/archive/2017/10/08/432851.html傻 瓜傻 瓜Sun, 08 Oct 2017 11:15:00 GMThttp://www.blogjava.net/fool/archive/2017/10/08/432851.htmlhttp://www.blogjava.net/fool/comments/432851.htmlhttp://www.blogjava.net/fool/archive/2017/10/08/432851.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432851.htmlhttp://www.blogjava.net/fool/services/trackbacks/432851.html1,启动elashticsearch
2,logstash/config目录下新建log.conf文件,其内容：
input {
  # For detail config for log4j as input, 
  # See: https://www.elastic.co/guide/en/logstash/current/plugins-inputs-log4j.html
      tcp { 
    mode => "server"
    host => "127.0.0.1"
        port => 4567
        codec => json_lines 
    }  
}
filter {
  #Only matched data are send to output.
}
output {
  # For detail config for elasticsearch as output, 
  # See: https://www.elastic.co/guide/en/logstash/current/plugins-outputs-elasticsearch.html
  elasticsearch {  
    hosts  => ["127.0.0.1:9200"]   #ElasticSearch host, can be array.
    index  => "applog"         #The index to write data to.
  }
}
3,kibana配置.修改kibana/config文件夹中的kibana.yml的配置文件
server.port: 5601
server.host: "localhost"
elasticsearch.url: "http://localhost:9200"
kibana.index: ".kibana"

4,springCload、springBoot中的logback-spring.xml文件配置将日志写入logstash

    <appender name="logstash2" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
        <remoteHost>127.0.0.1</remoteHost>
        <port>4567</port>
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <!-- Minimum logging level to be presented in the console logs-->
            <level>INFO</level> <!--写入logstash的日志级别-->
        </filter>
        <encoder charset="UTF-8" class="net.logstash.logback.encoder.LogstashEncoder"/>
    </appender>
    ​
    <root level="INFO">
        <appender-ref ref="console"/>
        <appender-ref ref="logstash"/>
        <appender-ref ref="logstash2"/>
        <!--<appender-ref ref="flatfile"/>-->
    </root>

后记:日志是直接写入到elashticsearch,可以集成kafka或redis作为缓冲。


傻 瓜 2017-10-08 19:15 发表评论
]]>springboot、mybatis、mycat分库实践http://www.blogjava.net/fool/archive/2017/10/01/432841.html傻 瓜傻 瓜Sun, 01 Oct 2017 09:40:00 GMThttp://www.blogjava.net/fool/archive/2017/10/01/432841.htmlhttp://www.blogjava.net/fool/comments/432841.htmlhttp://www.blogjava.net/fool/archive/2017/10/01/432841.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432841.htmlhttp://www.blogjava.net/fool/services/trackbacks/432841.html1.pom文件中引入下面引入mybatis逆向工程插件
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.mybatis.generator</groupId>
<artifactId>mybatis-generator-maven-plugin</artifactId>
<version>1.3.4</version>
<configuration>
<verbose>true</verbose>
<overwrite>true</overwrite>
</configuration>
</plugin>
</plugins>
</build>
   2, src/main/resource 目录下引入mybatis逆向工程配置文件，这样就可以自动生成mybatis需要的xml及dao interface
<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE generatorConfiguration
   PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
   "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
 <generatorConfiguration>
     <!--数据库驱动-->
     <classPathEntry    location="E:\\worksource\\springboot\\src\\main\\webapp\\WEB-INF\\lib\\mysql-connector-java-5.1.39.jar"/>
     <context id="DB2Tables"    targetRuntime="MyBatis3">
         <commentGenerator>
             <property name="suppressDate" value="true"/>
             <property name="suppressAllComments" value="true"/>
         </commentGenerator>
         <!--数据库链接地址账号密码-->
         <jdbcConnection driverClass="com.mysql.jdbc.Driver" connectionURL="jdbc:mysql://localhost:3306/jeeshop" userId="root" password="">
         </jdbcConnection>
         <javaTypeResolver>
             <property name="forceBigDecimals" value="false"/>
         </javaTypeResolver>
         <!--生成Model类存放位置-->
         <javaModelGenerator targetPackage="com.junjun.myblog.domain" targetProject="src/main/java">
             <property name="enableSubPackages" value="true"/>
             <property name="trimStrings" value="true"/>
         </javaModelGenerator>
         <!--生成映射文件存放位置-->
         <sqlMapGenerator targetPackage="src/main/resources/mapper" targetProject=".">
             <property name="enableSubPackages" value="true"/>
         </sqlMapGenerator>
         <!--生成Dao类存放位置-->
         <javaClientGenerator type="XMLMAPPER" targetPackage="com.junjun.myblog.dao" targetProject="src/main/java">
             <property name="enableSubPackages" value="true"/>
         </javaClientGenerator>
         <!--生成对应表及类名 mapperName="AreaDao"  工程右键 Debug As -> maven build... -> mybatis-generator:generate
         <table tableName="t_area"   domainObjectName="Area" enableCountByExample="false" enableUpdateByExample="false" enableDeleteByExample="false" enableSelectByExample="false" selectByExampleQueryId="false"></table>
    -->
</context>
 </generatorConfiguration>
3,application 中加上注解  @MapperScan("com.junjun") 
4，数据源连接mycat
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:8066/MYSQL?useUnicode=true&characterEncoding=UTF-8
spring.datasource.username=root
spring.datasource.password=123456
二，mycat配置
1,conf/server.xml中配置用户 和schema
<user name="root">
<property name="password">123456</property>
<property name="schemas">MYSQL</property>
</user>
2,schema.xml配置数据库和分片表分片规则
<schema name="MYSQL" checkSQLschema="false" sqlMaxLimit="100">
<table name="t_blogger" primaryKey="id" dataNode="dn1" >     </table> 
<!--按需配置分片规则-->
        <table name="t_area" primaryKey="id" dataNode="dn1,dn2,dn3" rule="mod-long1">     </table> 
<table name="t_blog" primaryKey="id" dataNode="dn1" >     </table> 
<table name="t_blogtype" primaryKey="id" dataNode="dn1" >     </table> 
</schema>
<!-- <dataNode name="dn1$0-743" dataHost="localhost1" database="db$0-743"
/> -->
<dataNode name="dn1" dataHost="localhost1" database="jeeshop" />
<dataNode name="dn2" dataHost="localhost2" database="jysystem" />
<dataNode name="dn3" dataHost="localhost3" database="dn3" />
<!--<dataNode name="dn4" dataHost="sequoiadb1" database="SAMPLE" />
<dataNode name="jdbc_dn1" dataHost="jdbchost" database="db1" />
<dataNode name="jdbc_dn2" dataHost="jdbchost" database="db2" />
<dataNode name="jdbc_dn3" dataHost="jdbchost" database="db3" /> -->
<dataHost name="localhost1" maxCon="1000" minCon="10" balance="0"
  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<!-- can have multi write hosts -->
<writeHost host="hostM1" url="localhost:3306" user="root"
   password="">
<!-- can have multi read hosts 
<readHost host="hostS2" url="192.168.1.200:3306" user="root" password="" /> -->
</writeHost>
<!-- <writeHost host="hostM2" url="localhost:3316" user="root" password="123456"/> -->
</dataHost>
<dataHost name="localhost2" maxCon="1000" minCon="10" balance="0"
  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<!-- can have multi write hosts -->
<writeHost host="hostM2" url="127.0.0.1:3306" user="root"
   password="">
<!-- can have multi read hosts 
<readHost host="hostS2" url="192.168.1.200:3306" user="root" password="" /> -->
</writeHost>
<!-- <writeHost host="hostM2" url="localhost:3316" user="root" password="123456"/> -->
</dataHost>
<dataHost name="localhost3" maxCon="1000" minCon="10" balance="0"
  writeType="0" dbType="mysql" dbDriver="native" switchType="1"  slaveThreshold="100">
<heartbeat>select user()</heartbeat>
<!-- can have multi write hosts -->
<writeHost host="hostM2" url="127.0.0.1:3306" user="root"
   password="">
<!-- can have multi read hosts 
<readHost host="hostS2" url="192.168.1.200:3306" user="root" password="" /> -->
</writeHost>
<!-- <writeHost host="hostM2" url="localhost:3316" user="root" password="123456"/> -->
</dataHost>
3,rule.xml配置分片规则
    添加如下规则 按表的name字段进行分片存储
<tableRule name="mod-long1">
<rule>
<columns>name</columns>
<algorithm>mod-long</algorithm>
</rule>
</tableRule>
备注：内容太多，记一下重点. 分库后连接查询不在同一个库是查不到数据的,真有这需要那就真需要考虑
设计是否合理了.


傻 瓜 2017-10-01 17:40 发表评论
]]>springboot中action绑定ServletRequest的attirbute的值传参http://www.blogjava.net/fool/archive/2017/09/29/432838.html傻 瓜傻 瓜Fri, 29 Sep 2017 03:58:00 GMThttp://www.blogjava.net/fool/archive/2017/09/29/432838.htmlhttp://www.blogjava.net/fool/comments/432838.htmlhttp://www.blogjava.net/fool/archive/2017/09/29/432838.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432838.htmlhttp://www.blogjava.net/fool/services/trackbacks/432838.html根据token查找到对应的用户信息。比如分布式框架中获取用户信息等.springboot中可以自
定义参数解析器来绑定参数，通过它可以拿到ServletRequest中的attirbute中的值进行参数
绑定。

自定义一个annotation,通过这个注解中的 name查找attribute中的key对应的值 

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface AttributeResolve {
String name() default "user";
}

自定义一个解析器类

import javax.servlet.http.HttpServletRequest;
import org.springframework.core.MethodParameter;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
public class AttributeArgumentResolver implements HandlerMethodArgumentResolver{
@Override
public Object resolveArgument(MethodParameter arg0, ModelAndViewContainer arg1, NativeWebRequest arg2,
WebDataBinderFactory arg3) throws Exception {
// TODO Auto-generated method stub
Object resultObj=null;
 AttributeResolve mp =  arg0.getParameterAnnotation(AttributeResolve.class);
 if(mp!=null) {
String attributeName= mp.name();
HttpServletRequest request = arg2.getNativeRequest(HttpServletRequest.class);
resultObj = request.getAttribute(attributeName);
 }
return resultObj;
}
@Override
public boolean supportsParameter(MethodParameter arg0) {
// TODO Auto-generated method stub
return  arg0.hasParameterAnnotation(AttributeResolve.class);
}

springboot中注册自定义的参数解析器
@Configuration
public class MyWebMvcConfig extends WebMvcConfigurerAdapter{
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(new AttributeArgumentResolver());
    }
}


使用方法.
需要在action调用前向HttpServletRequest中的attribute中注入值 ，可以自定义一个filter,在filter中进行处理
如在filter中处理app传过来的token验证后取得对应的用户信息等.下面例子简单放入一个对象
@WebFilter(filterName = "axssFilter", urlPatterns = "/*",
initParams = {
@WebInitParam(name = "ignores", value = "*.js,*.gif,*.jpg,*.bmp,*.png,*.css,*.ico,/druid/*")// 忽略资源
}
)
public class XssFilter implements javax.servlet.Filter{
private Set<String> prefixIignores = new HashSet<String>();
@Override
public void destroy() {
// TODO Auto-generated method stub
}
@Override
public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain)
throws IOException, ServletException {
// TODO Auto-generated method stub
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;
            Blogger user = new Blogger();
          user.setUsername("asfdasdf");
         request.setAttribute("user", user);
               chain.doFilter(request, response);  
}
}

action获取attribute中放入的对象
        @RequestMapping("/index")
public String index(@AttributeResolve(name="user") Bloggerbh, HttpServletRequest request,Model model) 

嗯，还算优雅




傻 瓜 2017-09-29 11:58 发表评论
]]>sbringboot异步执行http://www.blogjava.net/fool/archive/2017/09/26/432832.html傻 瓜傻 瓜Tue, 26 Sep 2017 04:26:00 GMThttp://www.blogjava.net/fool/archive/2017/09/26/432832.htmlhttp://www.blogjava.net/fool/comments/432832.htmlhttp://www.blogjava.net/fool/archive/2017/09/26/432832.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432832.htmlhttp://www.blogjava.net/fool/services/trackbacks/432832.html
import java.util.concurrent.Executor;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
@Configuration
@EnableAsync   //开启异步任务支持
public class TaskExcutorConfig implements AsyncConfigurer {
@Override
public Executor getAsyncExecutor() {
// TODO Auto-generated method stub
ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
taskExecutor.setMaxPoolSize(10);
taskExecutor.setQueueCapacity(20);
taskExecutor.setCorePoolSize(5);
taskExecutor.initialize();
return taskExecutor;
}
@Override
public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
// TODO Auto-generated method stub
return null;
}

任务类或方法

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
//@Async 写在这里则整个类的方法都 是异步执行
@Service
public class AsynTestService {
@Async   //需要异步执行的方法
public void asyncTest() {
for(int i = 0; i < 10;i++) {
System.out.println(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}


傻 瓜 2017-09-26 12:26 发表评论
]]>springboot文件上传等杂项http://www.blogjava.net/fool/archive/2017/09/18/432826.html傻 瓜傻 瓜Mon, 18 Sep 2017 03:01:00 GMThttp://www.blogjava.net/fool/archive/2017/09/18/432826.htmlhttp://www.blogjava.net/fool/comments/432826.htmlhttp://www.blogjava.net/fool/archive/2017/09/18/432826.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432826.htmlhttp://www.blogjava.net/fool/services/trackbacks/432826.htmlspringmvc中配置文件上传写法在boot并不支持
@Bean
public MultipartResolver multipartResolver() {
CommonsMultipartResolver multipartResolver = new CommonsMultipartResolver();
multipartResolver.setMaxUploadSize(100000000);
return multipartResolver;
}
得这样写
  @Bean
   public MultipartConfigElement multipartConfigElement() {
       MultipartConfigFactory factory = new MultipartConfigFactory();
       factory.setMaxFileSize("128KB");
       factory.setMaxRequestSize("128KB");
       return factory.createMultipartConfig();
   }

2,拦截器
继承HandlerInterceptorAdapter确实可以拦截，但是afterCompletion在preHandle方法返回false后并
不执行，那么只能在preHandle中处理了，比如转向，ajax请求返回内容

3,关于快速跳转
有时候只是做一个简单的跳转，可以集中写在这里
public void addViewControllers(ViewControllerRegistry registry) {
registry.addViewController("/index").setViewName("/index");
       registry.addViewController("/converter").setViewName("/converter");
}

完整示例：
package com.example.demo.config;
import java.util.List;
import javax.servlet.MultipartConfigElement;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.PathMatchConfigurer;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.view.InternalResourceViewResolver;
import org.springframework.web.servlet.view.JstlView;
//其中默认配置的 /** 映射到 /static （或/public、/resources、/META-INF/resources） 
//其中默认配置的 /webjars/** 映射到 classpath:/META-INF/resources/webjars/ 
/*
spring.mvc.static-path-pattern=
@Configuration
public class MyWebAppConfigurer extends WebMvcConfigurerAdapter {
public void addResourceHandlers(ResourceHandlerRegistry registry) {
registry.addResourceHandler("/myres/**").addResourceLocations("classpath:/myres/");
//使用外部目录 registry.addResourceHandler("/api_files/**").addResourceLocations("file:D:/data/api_files");
super.addResourceHandlers(registry);
}
@Bean
public InternalResourceViewResolver viewResolver() {
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setPrefix("/WEB-INF/views/");
viewResolver.setSuffix(".jsp");
viewResolver.setViewClass(JstlView.class);
return viewResolver;
}
//拦截器
@Override
public void addInterceptors(InterceptorRegistry registry) {// 2
InterceptorRegistration i=registry.addInterceptor(demoInterceptor());
i.addPathPatterns("/jsp/*");//只拦截 /jsp/* 的action
}
@Bean
// 1  配置拦截器
public DemoInterceptor demoInterceptor() {
return new DemoInterceptor();
}
//快速转向
@Override
public void addViewControllers(ViewControllerRegistry registry) {
// registry.addViewController("/index").setViewName("/index");
registry.addViewController("/toUpload").setViewName("/upload");
registry.addViewController("/converter").setViewName("/converter");
registry.addViewController("/sse").setViewName("/sse");
registry.addViewController("/async").setViewName("/async");
}
   @Bean
   public MultipartConfigElement multipartConfigElement() {
       MultipartConfigFactory factory = new MultipartConfigFactory();
       factory.setMaxFileSize("128KB");
       factory.setMaxRequestSize("128KB");
       return factory.createMultipartConfig();
   }
}
拦截器类
public class DemoInterceptor extends HandlerInterceptorAdapter {// 1
@Override
public boolean preHandle(HttpServletRequest request, // 2
HttpServletResponse response, Object handler) throws Exception {
long startTime = System.currentTimeMillis();
System.out.println("本次始请求处理时间为:" + startTime + "ms");
request.setAttribute("startTime", startTime);
if (request.getHeader("x-requested-with") != null
&& request.getHeader("x-requested-with").equalsIgnoreCase("XMLHttpRequest")) {
response.setHeader("sessionstatus", "timeout"); // 响应头设置session状态
} else {
response.sendRedirect("/");
}
return false;
}
@Override
public void postHandle(HttpServletRequest request, // 3
HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
long startTime = (Long) request.getAttribute("startTime");
request.removeAttribute("startTime");
long endTime = System.currentTimeMillis();
System.out.println("本次请求处理时间�?:" + new Long(endTime - startTime) + "ms");
request.setAttribute("handlingTime", endTime - startTime);
}
}
文件上传页面upload.jsp
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>upload page</title>
</head>
<body>
<div class="upload">
<form action="upload" enctype="multipart/form-data" method="post">
<input type="file" name="file"/><br/>
<input type="submit" value="上传">
</form>
</div>
</body>
</html>

文件上传控制器类

@Controller
public class UploadController {
@RequestMapping(value = "/upload",method = RequestMethod.POST)
//MultipartFile[] ,涓婁紶澶氫釜鏂囦欢
public @ResponseBody String upload(@RequestParam("file") MultipartFile file) {//1
try {
FileUtils.writeByteArrayToFile(new File("e:/upload/"+file.getOriginalFilename()),
file.getBytes()); //2
return "ok";
} catch (IOException e) {
e.printStackTrace();
return "wrong";
}
}
}


傻 瓜 2017-09-18 11:01 发表评论
]]>springboot中的jsp支持http://www.blogjava.net/fool/archive/2017/09/18/432823.html傻 瓜傻 瓜Mon, 18 Sep 2017 01:22:00 GMThttp://www.blogjava.net/fool/archive/2017/09/18/432823.htmlhttp://www.blogjava.net/fool/comments/432823.htmlhttp://www.blogjava.net/fool/archive/2017/09/18/432823.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432823.htmlhttp://www.blogjava.net/fool/services/trackbacks/432823.html
       <dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
      </dependency>
   <dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.apache.tomcat.embed</groupId>
<artifactId>tomcat-embed-jasper</artifactId>
<scope>provided</scope>
</dependency>

写配置类配置jsp支持
@Configuration
public class MyWebAppConfigurer extends WebMvcConfigurerAdapter {

@Bean
public InternalResourceViewResolver viewResolver() {
InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
viewResolver.setPrefix("/WEB-INF/views/");
viewResolver.setSuffix(".jsp");
viewResolver.setViewClass(JstlView.class);
return viewResolver;
}

}

所谓零配置。。。 一言难尽


傻 瓜 2017-09-18 09:22 发表评论
]]>js外部调用更新angularjs的ng-repeat视图问题 http://www.blogjava.net/fool/archive/2017/09/11/432808.html傻 瓜傻 瓜Mon, 11 Sep 2017 13:37:00 GMThttp://www.blogjava.net/fool/archive/2017/09/11/432808.htmlhttp://www.blogjava.net/fool/comments/432808.htmlhttp://www.blogjava.net/fool/archive/2017/09/11/432808.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432808.htmlhttp://www.blogjava.net/fool/services/trackbacks/432808.html新table中数据就有些麻烦。所以用angularjs重构一下。
页面中angularjs展示数据  
<body   ng-controller="multi"> 
  <table id="baseTable" class="table table-striped table-bordered table-hover" >
<thead>
<tr><th style="width:10%" class="center">标题</th>
</tr>
</thead>
               <body   ng-controller="multi">   
                <tbody>  
                         <tr ng-repeat="item in defaultData " >
                             <td class='center hidden-480'>{{item.title}}</td>    
               </tr> 
  </tbody>
            </body>
  </table>
</body>
外部jquery的ajax调用更新数据 
                    var controllerScope = $('body[ng-controller="multi"]').scope();
            controllerScope.defaultData=results;
            controllerScope.$apply();
          
注意：外部js不要删除了下面这段代码块。
                        <tr ng-repeat="item in defaultData " >
                             <td class='center hidden-480'>{{item.title}}</td>    
                 </tr> 


傻 瓜 2017-09-11 21:37 发表评论
]]>业务规则与自定义规则处理库http://www.blogjava.net/fool/archive/2017/08/20/432763.html傻 瓜傻 瓜Sun, 20 Aug 2017 06:52:00 GMThttp://www.blogjava.net/fool/archive/2017/08/20/432763.htmlhttp://www.blogjava.net/fool/comments/432763.htmlhttp://www.blogjava.net/fool/archive/2017/08/20/432763.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432763.htmlhttp://www.blogjava.net/fool/services/trackbacks/432763.html更改或者新增新的业务规则.尤其是在某些场合如促销，积分商城等场景。正因为规则如此重要，建议使用单独的文档
维护，规则名称编号可以与用例名称编对一一对应。
业务规则分类：
一,内禀规则：业务实体本身的规则。如订单中销售记录不能为空，数量不能为等。
二，全局规则：一般与所有用例相关而不是某个特定用例相关。例如系统安全方面的sql注入，ddos攻击等。
三，交互规则：用于用例当中。它们规定了满足什么条件后业务将如何反应。有些规则需要开发成系统用例。比如人事
管理系统中请假业务只有工作日才计入请假天数，那么这个工作日就需要电脑来维护了，会作为一个系统用例存在，并
且作为请假用例的前置条件。 交互规则又是最容易引起.
交互规则如此灵活多变，需要良好的设计才能保证系统的扩展性和可维护性。如何做：
思路一：
    在 javax.swing.border包提供了Border接口和几个不同的Boder的实现。在swing中每个组件提供了paint方法，每
个组件知道怎么画自己展示自己的外观。那么我们可以提供业务规则处理接口，每个具体业务规则自己知道怎么处理业务。
可以用简单工厂来决定调用哪一个具体业务规则。这个是策略模式的使用,缺点是新增具体业务时工厂类会修改。也可以
用观察者模式来实现，所有的具体业务类都来观察这个业务规则，自己判断是不是自己可以处理的，不是就不理会。
基于策略模式的规则实现类图:

思路二：
     规则引擎比如drools处理一些问题 。规则引擎适合于做业务规则频繁变化的场景.把业务规则抽出来通过规则引擎来
处理。类似工作流系统的概念。

自定义规则处理库:
     一些动态的语言很适合来做这样的事情。java支持script.Mvel是一个表达式语言，drools也支持mvel来处理业务规则.
这里自定义规则引擎使用Mvel表达式语言.
      规则文件示例：
     <rules>
       <!--rule-set 是一个规则集,执行规则 rule1时会迭代规则集里面所有的规则(mvel-rule)-->
<rule-set name="rule1">
<!-- id是规则的标识，也是默认的排序处理顺序。exclusive 是排它。如果为true,则当前规则执行后，不再执行后面的规则-->
<mvel-rule id="step1"  exclusive="false">
<block><![CDATA[
if(salary<=3500) {result=0;}
]]></block>
</mvel-rule>
<mvel-rule id="step2" exclusive="false">
<block><![CDATA[if(salary>3500) {result=1};]]></block>
</mvel-rule>
</rule-set>
<rule-set name="rule2">
<mvel-rule id="step1"  exclusive="false">
<block><![CDATA[ 
             import  com.custom.rule.*;
             rs = new RuleSet(); 
             rs.name="asdf";
              rs.print();
         ]]></block>
</mvel-rule>
</rule-set>
</rules>
rule2中可见mvel可以导入未知jar包并进行处理，确实强大，就有了足够的灵活性. 自定义规则库源码及使用示例下载.
本例依赖xstream1.4.9 ,mvel2.0
自定义规则库除了可以应用于一般系统业务处理，当然也还可以用于大数据处理。比如hadoop/spark统计用户积分等
如果再定义一套配置规则的UI。。。好的，业务人员可以自己设置计算规则了。








傻 瓜 2017-08-20 14:52 发表评论
]]>架构设计过程分析小结http://www.blogjava.net/fool/archive/2017/04/28/432490.html傻 瓜傻 瓜Fri, 28 Apr 2017 06:22:00 GMThttp://www.blogjava.net/fool/archive/2017/04/28/432490.htmlhttp://www.blogjava.net/fool/comments/432490.htmlhttp://www.blogjava.net/fool/archive/2017/04/28/432490.html#Feedback0http://www.blogjava.net/fool/comments/commentRss/432490.htmlhttp://www.blogjava.net/fool/services/trackbacks/432490.html架构设计过程简单总结：架构设计的驱动力=功能+质量+约束.功能即系统要满足的业务需求。质量包括运行期质量和开发期质量. 常见的运行期质量属性包括软件系统的易用性、性能、可伸缩性、持续可用性、鲁棒性、安全性等。开发期质量属性是开发人员最为关心的，要达到怎样的目标应根据项目的具体情况而定。约束可能是商业预算，运行环境，使用人员水平，开发团队水平等。架构设计过程如下:

一，需求收集，分析。

此处省略2000字。。。 见前篇 《需求收集、分析小结》http://www.blogjava.net/fool/archive/2017/04/28/432489.html

二，概念架构/概念模型

从需求中找出关健、重大需求，进行概念建模.下面三个图称之鲁棒图。其中控制对象理解为mvc模式中的控制器和model。使用鲁棒图可以建立概念模型，约等于初步设计。初步设计并不关心细节。

 

 鲁棒图建立概念模型语法:

概念设计举例：


上次谈到超市小票如何分析实体对象,本次接着举例如何对收银进行概念建模



如上图：具备基本收银功能的概念模型。概念模型建模可以是增量的。比如商品折扣或其它

促销活动等。


概念架构的用途：

1） 可以帮助我们找出领域模型中的实体对象。

2） 检查需求用例是否正确和完善。

3）初步设计,鲁棒图是一种初步设计技术。

4）根据用例和概念设计划分系统、子系统、模块或者包。借助鲁棒图,初步识别功能背后的职责，规划切分系统的方式。

 

三，关注非功能性需求，包括运行期质量和开发期质量。

运用目标—场景—决策表对非功能性需求作出决策.小举例：

目标

场景

决策

易用性

销售员需要输入条码检索商品,繁琐且速度慢

根据条码，品名模糊匹配检索商品,提供辅助录入。

性能

长时间稳定运行

数据库集群，服务应用集群                                        
        技术选型                             需要管理钱箱、打印机、响应速    pos系统使用c/s
                                                度快

 

 

 

四，细化架构。RUP 4+1视图法则将架构需要关注的不同的点使用不同的视图表示.从不同的维度对系统进行解读,从而形成统一软件过程架构描述。

运行架构：

关心进程、线程、同步的相关设计，捕捉并发和同步特征

逻辑架构：

关心逻辑层(layer)的划分，系统/子系统的划分，划分模块及其接口的定义。功能组划分也属于逻辑架构.功能:不仅包括用户可见的功能，还包括为实现用户功能而必须提供的"辅助功能模块"；它们可能是逻辑层、功能模块等。

物理架构：

关心服务器选型，物理层划分(tier)。 描述如何部署机器和网络来配合软件系统的可靠性、可伸缩性等要求.layer就运行在tier上。Tier反映系统伸缩能力。

开发架构：

描述了在开发环境中软件的静态组织结构。即开发工具下的开发视图，描述文件编译及其依赖关系。而使用maven管理开发的项目编译及依赖关系结构更加分明。

数据架构：

关心数据的存储、分布和文件的存放及数据的复制，传递，同步。数据的存放包括sql,内存数据库，nosql数据库等.

 

逻辑架构设计举例：

还是用收银系统简单举例，收银系统逻辑架构图如下：



整个系统划系统为系统，切为两个系统，一个收银员角色处理的业务，收银系统。

一个后台管理系统。后台管理系统包括用户管理模块，基础资料模块（产品资料等）

销售模块（本例对销售单）。另外，因为收银系统需要和后台系统交互，把收银系统需要使用到的相关的各模块封装成一个接口模块，专门处理和收银系统交互的模块。系统、模块之间的通讯方式应当尽量避免双向。相互依赖可能会引发很多问题。

 

物理架构设计举例：

物理架构和逻辑架构可以相互印证。描述软件系统的物理布署。



如果考虑运行期质量比如长时间运行布署图可能应用做集群。数据库做集群等。逻辑层layer运行在物理层tier之上

 

运行架构和数据架构视图根据实际情况可选设计





傻 瓜 2017-04-28 14:22 发表评论
]]>