开发环境必备软件：

 composer-cli

 generator-hyperledger-composr

composer-rest-server
Yeoman

安装playground

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!

一，需求收集，分析。

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

二，概念架构/概念模型

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

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

概念设计举例：

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

促销活动等。

概念架构的用途：

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

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

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

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

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

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

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

运行架构：

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

逻辑架构：

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

物理架构：

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

开发架构：

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

数据架构：

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

逻辑架构设计举例：

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

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

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

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

物理架构设计举例：

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

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

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

 <bean id="filterChainProxy"
  class="org.acegisecurity.util.FilterChainProxy">
  <property name="filterInvocationDefinitionSource">
   <value>
    CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
    PATTERN_TYPE_APACHE_ANT
    /**=httpSessionContextIntegrationFilter,logoutFilter,authenticationProcessingFilter,securityContextHolderAwareRequestFilter,rememberMeProcessingFilter,anonymousProcessingFilter,exceptionTranslationFilter,filterInvocationInterceptor
   </value>
  </property>
 </bean>

 <bean id="authenticationManager"
  class="org.acegisecurity.providers.ProviderManager">
  <property name="providers">
   <list>
     <!-- 自己写一个认证提供者类 我加的-->
       <ref local="activeDirectoryProvider" />
    <ref local="daoAuthenticationProvider" />
    <ref local="anonymousAuthenticationProvider" />
    <ref local="rememberMeAuthenticationProvider" />
   </list>
  </property>
 
 </bean>
 
 <!-- 认证提供者类的配置 我加的-->
 <bean id="activeDirectoryProvider"
  class="net.omw.utility.AcegiTestProvider">
  <property name="url" value="ldap://172.108.4.2"> </property>
  <property name="port" value="389"> </property>
<!--domain取值域服务器的配置-->
  <property name="domain" value="SUNTECH"> </property>
  <!--    <property name="sessionController" ref="concurrentSessionController"></property> -->
 </bean>


 <bean id="jdbcDaoImpl"
  class="org.acegisecurity.userdetails.jdbc.JdbcDaoImpl">
  <property name="dataSource">
   <ref bean="coreDataSource" />
  </property>
  <property name="usersByUsernameQuery">
   <value>
    select C_OPER_ID,C_PASSWORD,1 from Operator where
    C_OPER_ID = ? and C_STATUS='Y'
   </value>
  </property>
  <property name="authoritiesByUsernameQuery">
   <value>
    select C_OPER_ID,C_PASSWORD,1 from Operator where
    C_OPER_ID = ? and C_STATUS='Y'
   </value>
  </property>
 </bean>

 <bean id="passwordEncoder"
  class="org.acegisecurity.providers.encoding.Md5PasswordEncoder">
  <property name="encodeHashAsBase64" value="false"></property>
 </bean>

 <bean id="daoAuthenticationProvider"
  class="org.acegisecurity.providers.dao.DaoAuthenticationProvider">
  <property name="userDetailsService">
   <ref local="jdbcDaoImpl" />
  </property>
  <!-- <property name="userCache">
   <ref local="userCache" />
  </property>-->
  <property name="passwordEncoder">
   <ref local="passwordEncoder" />
  </property>
 </bean>

 <bean id="cacheManager"
  class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean" />

 <bean id="userCacheBackend"
  class="org.springframework.cache.ehcache.EhCacheFactoryBean">
  <property name="cacheManager">
   <ref local="cacheManager" />
  </property>
  <property name="cacheName">
   <value>userCache</value>
  </property>
 </bean>

 <bean id="userCache"
  class="org.acegisecurity.providers.dao.cache.EhCacheBasedUserCache">
  <property name="cache">
   <ref local="userCacheBackend" />
  </property>
 </bean>

 <bean id="loggerListener"
  class="org.acegisecurity.event.authentication.LoggerListener" />

 <bean id="anonymousProcessingFilter"
  class="org.acegisecurity.providers.anonymous.AnonymousProcessingFilter">
  <property name="key">
   <value>foobar</value>
  </property>
  <property name="userAttribute">
   <value>anonymousUser,ROLE_ANONYMOUS</value>
  </property>
 </bean>

 <bean id="anonymousAuthenticationProvider"
  class="org.acegisecurity.providers.anonymous.AnonymousAuthenticationProvider">
  <property name="key">
   <value>foobar</value>
  </property>
 </bean>

 <bean id="httpSessionContextIntegrationFilter"
  class="org.acegisecurity.context.HttpSessionContextIntegrationFilter">
 </bean>

 <bean id="rememberMeProcessingFilter"
  class="org.acegisecurity.ui.rememberme.RememberMeProcessingFilter">
  <property name="authenticationManager">
   <ref local="authenticationManager" />
  </property>
  <property name="rememberMeServices">
   <ref local="rememberMeServices" />
  </property>
 </bean>

 <bean id="rememberMeServices"
  class="org.acegisecurity.ui.rememberme.TokenBasedRememberMeServices">
  <property name="userDetailsService">
   <ref local="jdbcDaoImpl" />
  </property>
  <property name="key">
   <value>springRocks</value>
  </property>
 </bean>

 <bean id="rememberMeAuthenticationProvider"
  class="org.acegisecurity.providers.rememberme.RememberMeAuthenticationProvider">
  <property name="key">
   <value>springRocks</value>
  </property>
 </bean>

 <bean id="logoutFilter"
  class="org.acegisecurity.ui.logout.LogoutFilter">
  <constructor-arg value="/login/loginPage.jsp" />
  <constructor-arg>
   <list>
    <ref bean="rememberMeServices" />
    <bean
     class="org.acegisecurity.ui.logout.SecurityContextLogoutHandler" />
   </list>
  </constructor-arg>
 </bean>

 <bean id="securityContextHolderAwareRequestFilter"
  class="org.acegisecurity.wrapper.SecurityContextHolderAwareRequestFilter" />

 <bean id="exceptionTranslationFilter"
  class="org.acegisecurity.ui.ExceptionTranslationFilter">
  <property name="authenticationEntryPoint">
   <ref local="authenticationProcessingFilterEntryPoint" />
  </property>
  <property name="accessDeniedHandler">
   <bean
    class="org.acegisecurity.ui.AccessDeniedHandlerImpl">
    <property name="errorPage"
     value="/common/AccessDenied.jsp" />
   </bean>
  </property>
 </bean>

 <bean id="authenticationProcessingFilter"
  class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilter">
  <property name="authenticationManager">
   <ref bean="authenticationManager" />
  </property>
  <property name="authenticationFailureUrl">
   <value>/login/Login.action?login_msg=1</value>
  </property>
  <property name="defaultTargetUrl">
   <value>/login/Login.action?login_msg=0</value>
  </property>
  <property name="filterProcessesUrl">
   <value>/j_acegi_security_check</value>
  </property>
  <property name="rememberMeServices">
   <ref local="rememberMeServices" />
  </property>
 </bean>

 <bean id="authenticationProcessingFilterEntryPoint"
  class="org.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
  <property name="loginFormUrl">
   <value>/login/loginPage.jsp</value>
  </property>
  <property name="forceHttps">
   <value>false</value>
  </property>
  <property name="serverSideRedirect" value="false"></property>
 </bean>

 <bean id="httpRequestAccessDecisionManager"
  class="org.acegisecurity.vote.AffirmativeBased">
  <property name="allowIfAllAbstainDecisions">
   <value>false</value>
  </property>
  <property name="decisionVoters">
   <list>
    <ref bean="roleVoter" />
   </list>
  </property>
 </bean>

 <bean id="roleVoter" class="org.acegisecurity.vote.RoleVoter" />

 <bean id="filterInvocationInterceptor"
  class="org.acegisecurity.intercept.web.FilterSecurityInterceptor">
  <property name="validateConfigAttributes" value="true" />
  <property name="authenticationManager">
   <ref bean="authenticationManager" />
  </property>
  <property name="accessDecisionManager">
   <ref local="httpRequestAccessDecisionManager" />
  </property>
  <property name="objectDefinitionSource"
   ref="rdbmsFilterInvocationDefinitionSource" />

 </bean>

 <bean id="rdbmsFilterInvocationDefinitionSource"
  class="net.omw.utility.acegi.interceptor.RdbmsFilterInvocationDefinitionSource">
  <property name="dataSource">
   <ref bean="coreDataSource" />
  </property>
  <property name="webresdbCache" ref="webresCacheBackend" />
 </bean>

 <bean id="webresCacheBackend"
  class="org.springframework.cache.ehcache.EhCacheFactoryBean">
  <property name="cacheManager">
   <ref local="cacheManager" />
  </property>
  <property name="cacheName">
   <value>webresdbCache</value>
  </property>
 </bean>

 <!-- 
  <bean id="switchUserProcessingFilter" class="org.acegisecurity.ui.switchuser.SwitchUserProcessingFilter">
  <property name="userDetailsService" ref="jdbcDaoImpl" />
  <property name="switchUserUrl"><value>/j_acegi_switch_user</value></property>
  <property name="exitUserUrl"><value>/j_acegi_exit_user</value></property>
  <property name="targetUrl"><value>/secure/index.htm</value></property>
  </bean>   
 -->

 <bean id="authenticationLoggerListener"
  class="org.acegisecurity.event.authentication.LoggerListener" />

 <bean id="authorizationLoggerListener"
  class="org.acegisecurity.event.authorization.LoggerListener" />
</beans>

AcegiTestProvider类从AbstractUserDetailsAuthenticationProvider继承,有两个方法必须实现
additionalAuthenticationChecks()和retrieveUser()方法.retrieveUser返回UserDetails,UserDetails的实现可以包装更多的信息.但在本例中几乎没什么太大的作用,仅仅是为了返回而重新定义了一个类
真正的验证逻辑发生在additionalAuthenticationChecks方法里抛出异常就算用户登录失败

package net.omw.utility;

import java.util.Properties;

import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.ldap.InitialLdapContext;

import org.acegisecurity.AuthenticationException;
import org.acegisecurity.GrantedAuthority;
import org.acegisecurity.GrantedAuthorityImpl;
import org.acegisecurity.providers.UsernamePasswordAuthenticationToken;
import org.acegisecurity.providers.dao.AbstractUserDetailsAuthenticationProvider;
import org.acegisecurity.userdetails.UserDetails;
import org.acegisecurity.userdetails.UsernameNotFoundException;

public class AcegiTestProvider extends
  AbstractUserDetailsAuthenticationProvider {
   private String url;
   private String port;
   private String domain;
 
 /*
  * 验证逻辑
  * @see org.acegisecurity.providers.dao.AbstractUserDetailsAuthenticationProvider#additionalAuthenticationChecks(org.acegisecurity.userdetails.UserDetails, org.acegisecurity.providers.UsernamePasswordAuthenticationToken)
  *
  */
 @Override
 protected void additionalAuthenticationChecks(UserDetails arg0,
   UsernamePasswordAuthenticationToken arg1)
   throws AuthenticationException {
  // TODO Auto-generated method stub

  String URL = url+":"+port;

        String username=domain+"\\"+arg0.getUsername();
  String password = arg0.getPassword();

  Properties env = new Properties();  
  env.put(Context.INITIAL_CONTEXT_FACTORY,
  "com.sun.jndi.ldap.LdapCtxFactory");
  env.put(Context.PROVIDER_URL,"ldap://172.18.0.42:389");
  env.put(Context.SECURITY_AUTHENTICATION,"simple");
  env.put(Context.SECURITY_PRINCIPAL,
  username);
  env.put(Context.SECURITY_CREDENTIALS,password);
  env.put("com.sun.jndi.ldap.connect.pool","true");
  env.put("java.naming.referral","follow"); 
  try{
    new InitialLdapContext(env,null);
  }
  catch(NamingException e){
   // Authentication failed
   throw new UsernameNotFoundException(e.toString());
   
  }

 }

 @Override
 protected UserDetails retrieveUser(String arg0,
   UsernamePasswordAuthenticationToken arg1)
   throws AuthenticationException {
  // TODO Auto-generated method stub
  GrantedAuthority[] authorities = new GrantedAuthority[1];
  authorities[0] = new GrantedAuthorityImpl("ROLE_SUPERVISOR");
  String password = (String) arg1.getCredentials();  
        /*String username = "";
  Object obj = arg1.getPrincipal();
  if (obj instanceof UserDetails) {
   username = ((UserDetails) obj).getUsername();
  } else {
   username = obj.toString();
  }
        */
  UserDetails userDetails = new UserDetailsImpl(authorities, password,
    arg1.getName(), true, true, true, true);
  //if(true)
    //  throw new AuthenticationCredentialsNotFoundException("t");
  
  return userDetails;
 }

 public String getUrl() {
  return url;
 }

 public void setUrl(String url) {
  this.url = url;
 }

 public String getPort() {
  return port;
 }

 public void setPort(String port) {
  this.port = port;
 }

 public String getDomain() {
  return domain;
 }

 public void setDomain(String domain) {
  this.domain = domain;
 }

 
}

package net.omw.utility;

import org.acegisecurity.GrantedAuthority;
import org.acegisecurity.userdetails.UserDetails;

public class UserDetailsImpl implements UserDetails {
 GrantedAuthority[] authorities;

 String password;

 String username;
 boolean isAccountNonExpired;

 boolean isAccountNonLocked;

 boolean isCredentialsNonExpired;

 boolean isEnabled;

 UserDetailsImpl(GrantedAuthority[] authorities, String password,
            String username, boolean isAccountNonExpired,
            boolean isCredentialsNonExpired, boolean isEnabled,
            boolean isAccountNonLocked) {
        this.authorities = authorities;
        this.isAccountNonExpired = isAccountNonExpired;
        this.isAccountNonLocked = isAccountNonLocked;
        this.isEnabled = isEnabled;
        this.password = password;
        this.username = username;
        this.isCredentialsNonExpired = isCredentialsNonExpired;

    }

 
 @Override
 public GrantedAuthority[] getAuthorities() {
  // TODO Auto-generated method stub
  return authorities;
 }

 @Override
 public String getPassword() {
  // TODO Auto-generated method stub
  return password;
 }

 @Override
 public String getUsername() {
  // TODO Auto-generated method stub
  return username;
 }

 @Override
 public boolean isAccountNonExpired() {
  // TODO Auto-generated method stub
  return isAccountNonExpired;
 }

 @Override
 public boolean isAccountNonLocked() {
  // TODO Auto-generated method stub
  return isAccountNonLocked;
 }

 @Override
 public boolean isCredentialsNonExpired() {
  // TODO Auto-generated method stub
  return isCredentialsNonExpired;
 }

 @Override
 public boolean isEnabled() {
  // TODO Auto-generated method stub
  return isEnabled;
 }

}

    public static void main(String[] args){
      Mozi mozi=new Mozi();
      Horse w=new WhiteHorse();
      Horse b=new BlackHorse();
      mozi.ride(w);
      mozi.ride(b);
    }
} 
程序打印输出:
ridding a horse
ridding a horse
原因就是对两次ride方法的调用传入的参量不同，但是它们的静态类型是一样的，都是 Horse;
这个过程在编译时期就完成了。
java通过方法置换支持动态分派。比如 String s1="ab"; Object o=s1+"c"; String s="abc";
o.equals(s) 打印true  o.equals()方法执行的是String类的equals()方法.java调用对象的
真实类型的方法，这就是动态分派。
双重分派:
public abstract class Vistor{

protected void processStrig(Object e){
 if(e instanceof String){
     String tmp=(String) e;
     String need="'"+e+"'";
     System.out.println(nedd);
   }else if(e instanceof Integer){
       String need=e.toString();
       System.out.println(need);
    }else if(e instanceof Date){
             Date tmp=(Date) e;
             String need="'"+tmp.toString()+"'";
        }
      ....
    }

}

public class ConcreteVisitor extends Visitor{

protected void processString(Object e){
     super.processString(e);
   }  
}
方法的调用Visitor v=new ConcreteVisitor(); v.processString(new String("tt"));
v.processString()方法在调用的时候会检察v的真实类型，调用真实类型的方法，这个时候就
发生了一动态的单分派过程.当子类调用超类的方法的时候明显的根据instanceof判断的真实类
型去执行不同的方法，又发生了一次动态分派的过程.这个就是双重分派的实现。这种方法实现的
程序比较冗长和容易出错.
“返传球”方案:
public abstract class Vistor{

   public abstract String processStrig(Object e);

}

public class ConcreteVisitor extends Visitor{

  public String processString(WrapperString e){
    String tmp= t.toString();
    System.out.println(tmp);
   }  

  public String processInteger(WrapperInteger e){
    String tmp=e.toString();
    System.out.println(tmp);

   }

}

public class abstract Wrapper{
  public abstract String processString(Vistor v);
}

public class WrapperString extends Wrapper{

  public String processString(Vistor v){
    v.processString(this);
   }
  public String toString(){
   ...
   }
}

public class WrapperInteger extends Wrapper{
    public String processInteger(Visitor v){
     v.processString(this);
    }
    public String toString(){
     ...
    }
 }
方法的调用：
Visitor v = new ConcreteVisitor();
Wrapper wrapper= new WrapperString();
wrapper.processString(v);
当wrapper.processString()方法执行的时候会检察wrapper的真实类型，这个就产生了一次
动态单分派，processString()里面的语句v.processString（）在执行的时候也会检察v的真
实类型，动态双重分派就发生了。
访问者模式的核心就是“返传球“方案的双重分派。其示意性类图:(注:虚线箭头划错了)





在一个方法内实现向不同的表插入不同数据的具体实现方案(简化了的）：因为整个方案里只需
要一个访问者对象，因此使用简化了的访问者模式。因为java基本类型及对应的类是不变模式的
实现：因此包装一下这些基本类型和类并实现访问者模式需要的方法。
public abstract class Wrapper {
    public Wrapper() {
    }
    public abstract String action(Visitor visitor);

}

包装Date类:
import java.util.Date;
public class WrapperDate extends Wrapper {
    private Date date;
    public WrapperDate(Date date) {
        this.date=date;
    }
    public String action(Visitor visitor){
         return( visitor.visit(this));
    }

    public String toString(){
        if (date==null){
            return "null";
        }
        return "'"+date.toString()+"'";
    }

}

包装Integer类:
public class WrapperInteger extends Wrapper {
    private Integer value;

    public WrapperInteger(Integer value) {
        this.value=value;

    }
    public WrapperInteger(int value){

        this.value=new Integer(value);
    }
    public WrapperInteger(String value){

      this.value=new Integer(value);
    }

    public String action(Visitor visitor){
       return( visitor.visit(this));
    }
    public String toString(){
        if(value==null){
            return "null";
        }
        return value.toString();
    }
}

包装String类:
public class WrapperString extends Wrapper {
    private String wrapper;
    public WrapperString( String wrapper) {

        this.wrapper = wrapper;
    }

    public WrapperString( char[] wrap) {
        wrapper = new String(wrap);
    }

    public String action(Visitor visitor) {
        return (visitor.vistit(this));
    }

    public String toString() {
        if(wrapper==null){
            return "null";
        }
        return "'" + wrapper + "'";
    }

}

具体访问者的实现：
public class Visitor {
    public Visitor() {
    }

    public String vistit(WrapperString wrap){
       return wrap.toString();
    }
    public String visit(WrapperInteger value){
        return value.toString();
    }
    public String visit(WrapperDate date){
        return date.toString();
    }
}

具体应用类的实现:

import java.util.*;

public class Test {

    private Visitor visitor = new Visitor();

    public Test() {
    }

    public Visitor getVisitor() {
        return visitor;
    }

    public int insertData(String tablename, List columNameCollection,
                          List values) {

        StringBuffer query = new StringBuffer("insert into " + tablename + " (");

        int count = 0;

        for (Iterator it = columNameCollection.iterator(); it.hasNext(); ) {
            String columName = (String) it.next();
            query.append(columName);
            query.append(",");
        }
        query.deleteCharAt(query.length() - 1);
        query.append(") values(");
        for (Iterator it = values.iterator(); it.hasNext(); ) {
            Wrapper wrapper = (Wrapper) it.next();
            String tmp = wrapper.action(getVisitor());
            query.append(tmp);
            query.append(",");
        }
        query.deleteCharAt(query.length() - 1);
        query.append(")");

        System.out.println(query.toString());
        return count;
    }

    public static void main(String[] args) {
        Test test = new Test();
        String tableName = "cutomer";
        List columNameCollection = new ArrayList();
        String columName = "name";
        String columAge = "age";
        String columFunctionTime="fuctiontime";
        columNameCollection.add(columName);
        columNameCollection.add(columAge);
        columNameCollection.add(columFunctionTime);
        List values = new ArrayList();
        String name=null;
        Wrapper wrapper1 = new WrapperString(name);
        Wrapper wrapper2 = new WrapperInteger(1);
        Wrapper wrapper3= new WrapperDate(new java.util.Date());
        values.add(wrapper1);
        values.add(wrapper2);
        values.add(wrapper3);
        test.insertData(tableName,columNameCollection,values);
       

    }
}

程序打印结果：

insert into cutomer (name,age,fuctiontime) values(null,1,'Sat Aug 12 13:46:58 CST 2006')

这个输出是满足MSSQL执行插入的语法要求的.虽然这样就实现了想要的结果,
但是insertData(String tablename, List columNameCollection, List values) 方法在每次调
用的时候需要输入表名跟该表的列的集合,还是很麻烦,不尽人意,而且不同的数
据库的表名是不一样的,因此最好用配置文件来解决这一个问题.

欢迎加入QQ群:30406099 

参数：
c - 要为其绘制边框的组件
g - 绘制的图形
x - 所绘制边框的 x 坐标位置
y - 所绘制边框的 y 坐标位置
width - 所绘制边框的宽度
height - 所绘制边框的高度

//附注:边框就是在这个方法中给画出来的
--------------------------------------------------------------------------------

Insets getBorderInsets(Component c)返回该边框的 insets。

//附注一下:该类是容器边界的表示形式。它指定容器必须在其各个边缘留出的空间。这个空间可以是边
//界、空白空间或标题。
参数：
c - 要应用此边框 insets 值的组件

--------------------------------------------------------------------------------

isBorderOpaque
boolean isBorderOpaque()返回此边框是否透明。如果边框为不透明，则在绘制它时将用自身的背景来填充。

接口的实现类  至于画图用到的方法,详见JAVA API.
import java.awt.*;
import java.awt.geom.*;

import javax.swing.*;
import javax.swing.border.*;

public class MyBorder implements Border
{
 //设置边框四周留出的空间
  protected int m_w=6;  
  protected int m_h=6;
  protected int m_left=16;
//设置边框的前景色跟背景色
  protected Color m_topColor = Color.white;
  protected Color m_bottomColor = Color.gray;

  public MyBorder() {
    m_w=6;
    m_h=6;
    m_left=16;
  }

  public MyBorder(int w, int h) {
    m_w=w;
    m_h=h;
  }

  public MyBorder(int w, int h, Color topColor,
   Color bottomColor) {
    m_w=w;
    m_h=h;
    m_topColor = topColor;
    m_bottomColor = bottomColor;
  }

  public Insets getBorderInsets(Component c) {
    return new Insets(m_h, m_left, m_h, m_w);
  }

  public boolean isBorderOpaque() { return true; }

  public void paintBorder(Component c, Graphics gd,
   int x, int y, int w, int h) {
    Graphics2D g = (Graphics2D) gd;
    w--;
    h--;
    g.setColor(m_topColor);
    g.drawLine(x, y+h, x, y+m_h);
    g.drawArc(x, y, 2*m_w, 2*m_h, 180, -90);
    g.drawLine(x, y, x+w-m_w, y);
    g.drawArc(x+w-2*m_w, y, 2*m_w, 2*m_h, 90, -90);
    int stringHeitht = y+h-5;

    Point2D.Float  p1 = new Point2D.Float(x,y+h);
    Point2D.Float p2 = new Point2D.Float(x,y);
    GradientPaint gradient = new GradientPaint(p1,Color.blue,p2,Color.gray,false);
    //g.setColor(Color.YELLOW);
    //g.drawRect();
    g.setPaint(gradient);
    g.fillRect(x,y,x+m_left,y+h);

    g.setColor(Color.GRAY);
    g.drawString("瓜",((x+m_left)-g.getFontMetrics().charWidth('傻'))/2,stringHeitht);
    int simpleFontHeitht = g.getFontMetrics().getHeight();
    stringHeitht-=simpleFontHeitht;
    g.drawString("傻",((x+m_left)-g.getFontMetrics().charWidth('傻'))/2,stringHeitht);

    g.setColor(m_bottomColor);
    g.drawLine(x+w, y+m_h, x+w, y+h);
   // g.drawArc(x+w-2*m_w, y+h-2*m_h, 2*m_w, 2*m_h, 0, -90);
   g.drawLine(x, y+h, x+w, y+h);
    //g.drawArc(x, y+h-2*m_h, 2*m_w, 2*m_h, -90, -90);
  }

}

剩下的就是把这个边框给它装上去了.在JMenu中有一个方法getPopupMenu()得到弹出菜单对象JPopupMenu;
然后调用这个JPopupMenu对象的setBorder方法就行了.下面是完整的测试程序

import java.awt.Toolkit;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;
import java.awt.Dimension;

public class Application1 {
  boolean packFrame = false;

  /**
   * Construct and show the application.
   */
  public Application1() {
    MenuFaces frame = new MenuFaces();
    // Validate frames that have preset sizes
    // Pack frames that have useful preferred size info, e.g. from their layout
    if (packFrame) {
      frame.pack();
    }
    else {
      frame.validate();
    }

    // Center the window
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    Dimension frameSize = frame.getSize();
    if (frameSize.height > screenSize.height) {
      frameSize.height = screenSize.height;
    }
    if (frameSize.width > screenSize.width) {
      frameSize.width = screenSize.width;
    }
    frame.setLocation( (screenSize.width - frameSize.width) / 2,
                      (screenSize.height - frameSize.height) / 2);
    frame.setVisible(true);
  }

  /**
   * Application entry point.
   *
   * @param args String[]
   */
  public static void main(String[] args) {
    SwingUtilities.invokeLater(new Runnable() {
      public void run() {
        try {
          UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        }
        catch (Exception exception) {
          exception.printStackTrace();
        }

        new Application1();
      }
    });
  }
}

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class MenuFaces
    extends JFrame {
  JPanel contentPane;
  BorderLayout borderLayout1 = new BorderLayout();
  JMenuBar jMenuBar1 = new JMenuBar();
  JMenu jMenuFile = new JMenu();
  JMenuItem jMenuFileExit = new JMenuItem();
  JMenuItem jMenuItem1 = new JMenuItem();
  JMenuItem jMenuItem2 = new JMenuItem();
  JMenuItem jMenuItem3 = new JMenuItem();
  JMenu jMenu1 = new JMenu();
  JMenuItem jMenuItem4 = new JMenuItem();

  public MenuFaces() {
    try {
      setDefaultCloseOperation(EXIT_ON_CLOSE);
      jbInit();
    }
    catch (Exception exception) {
      exception.printStackTrace();
    }
  }

  /**
   * Component initialization.
   *
   * @throws java.lang.Exception
   */
  private void jbInit() throws Exception {
    contentPane = (JPanel) getContentPane();
    contentPane.setLayout(borderLayout1);
    setSize(new Dimension(400, 300));
    setTitle("Frame Title");
    jMenuFile.setText("File");
    jMenuFileExit.setText("Exit");
    jMenuFileExit.addActionListener(new MenuFaces_jMenuFileExit_ActionAdapter(this));
    jMenuItem1.setText("open");
    jMenuItem2.setText("save");
    jMenuItem3.setText("save as");
    jMenu1.setText("other");
    jMenuItem4.setText("tt");
    jMenuBar1.add(jMenuFile);
    jMenuBar1.add(jMenu1);
    jMenuFile.add(jMenuItem3);
    jMenuFile.add(jMenuItem2);
    jMenuFile.add(jMenuItem1);
    jMenuFile.add(jMenuFileExit);
    jMenu1.add(jMenuItem4);
    JPopupMenu tt = jMenuFile.getPopupMenu();
    MyBorder myBorder = new MyBorder();
    tt.setBorder(myBorder);

    setJMenuBar(jMenuBar1);
  }

  /**
   * File | Exit action performed.
   *
   * @param actionEvent ActionEvent
   */
  void jMenuFileExit_actionPerformed(ActionEvent actionEvent) {
    System.exit(0);
  }
}

class MenuFaces_jMenuFileExit_ActionAdapter
    implements ActionListener {
  MenuFaces adaptee;

  MenuFaces_jMenuFileExit_ActionAdapter(MenuFaces adaptee) {
    this.adaptee = adaptee;
  }

  public void actionPerformed(ActionEvent actionEvent) {
    adaptee.jMenuFileExit_actionPerformed(actionEvent);
  }
}


欢迎加入QQ群:30406099