vm复制代码## 定义一个user变量为李白, password变量为123456 
#set{$user = "李白"}
#set{$password = "123456"}

## 变量引用
#set{$student.name = "李白"}
## 数字
#set{$student.age = 22}
## 字符串
#set{$student.class = "大班"}
## 属性引用  
#set($student.address = $address.info)

vm复制代码#set{$user = "李白"}
## 输入		结果
$user		 李白
\$user		 $user
\\$user		 \李白
\\\$user	 \$user

vm复制代码#foreach ( $element in $list)
	## 集合中每个元素
	$element
	## 集合的序号 从1开始
	${velocityCount}
	## 集合的长度
	${list.size()}
#end

vm复制代码#foreach ($entry in $map.entrySet())
## map的key   map的value值
$entry.key => $entry.value
#end

vm复制代码#if (condition1)
	// 执行业务
#elseif (condition2)
	// 执行业务
#else
	// 执行业务
#end

vm复制代码#if (condition1)
	// 执行业务
#else
	// 执行业务
#end

vm复制代码#if (condition1)
  ## 条件符合跳过
  #if($user == "李白")
    #break;
  #end
#else
	// 执行业务
#end

vm复制代码#if (condition1)
  ## 条件符合直接终止
  #if($user == "李白")
    #stop
  #end
#else
	// 执行业务
#end

vm复制代码## 定义一个user变量为李白
#set{$user = "李白"}

vm复制代码#*  
  定义一个user变量
  将user变量赋值为 李白
*#
#set{$user = "李白"}

vm复制代码 #** 
 	@version 1.1
 	@author  李白
 *#
#set{$user = "李白"}

vm复制代码#include( "one.gif","two.txt","three.htm" )

vm复制代码##  a.vm文件
#set($user = "李白")


## b.vm文件
#parse("a.vm")
## 变量   值
$user	  李白

java复制代码public class VelocityUtils {

    public static void main(String[] args) {

        // 模板路径
        String templatePath = "D:\\work";
        // 模板名称
        String templateName = "index.html.vm";
        // 生成文件路径
        String outFilePath = "D:\\index.html";
        // 模板中所需参数
        Map<String, Object> params = new HashMap<>();
        params.put("name", "world");
        List<String> list =  new ArrayList<>();
        list.add("李白");
        list.add("杜甫");
        list.add("陆游");
        params.put("list", list);

        getFile(templatePath,templateName,outFilePath,params);
    }

    /**
     * 读取本地模板,生成文件
     * @param templatePath  模板路径
     * @param templateName 模板名称
     * @param outFilePath 生成文件路径
     * @param params 模板中填充参数
     */
    public static void getFile(String templatePath, String templateName, String outFilePath,
            Map<String, Object> params) {
        try {
            // 创建属性
   			loadTemplateFileByTwo(templatePath);

            // 封装填充参数
            VelocityContext context = new VelocityContext(params);
            // 获取模板
            Template tpl = Velocity.getTemplate(templateName, "UTF-8");
            // 创建输出流
            Writer writer = new PrintWriter(new FileOutputStream(new File(outFilePath)));
            // 模板与数据填充
            tpl.merge(context, writer);
            // 刷新数据
            writer.flush();
			writer.close();  
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
   /**
     * 送请求， 将生成的模板文件使用zip压缩包返回
     * @param response 响应对象
     * @param params 模板封装参数
     * @throws IOException
     */
    public static void createFile(HttpServletResponse response, Map<String, Object> params)
            throws IOException {
        
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        ZipOutputStream outZip = new ZipOutputStream(output);

        // 设置velocity资源加载器
        loadTemplateFileByOne();

        // 封装模板数据
        VelocityContext context = new VelocityContext(params);

        //获取模板列表
        List<String> templates = getTemplates();
        for (String template : templates) {
            // 渲染模板
            StringWriter sw = new StringWriter();
            Template tpl = Velocity.getTemplate(template, "UTF-8");
            tpl.merge(context, sw);
            
            // 添加数据
            outZip.putNextEntry(new ZipEntry(getFileName(template)));
            IOUtils.write(sw.toString(), outZip, "UTF-8");
            IOUtils.closeQuietly(sw);
        }

        IOUtils.closeQuietly(outZip);
        byte[] data = output.toByteArray();

        // 生成zip压缩包响应
        response.setHeader("Content-Disposition", "attachment; filename=\"template-file.zip\"");
        response.addHeader("Content-Length", String.valueOf(data.length));
        response.setContentType("application/octet-stream; charset=UTF-8");
        IOUtils.write(data, response.getOutputStream());

    }

    /**
     * 获取文件名
     */
    /**
     * @param template 模板名 如index.html.vm
     */
    private static String getFileName(String template) {
        return template.replace(".vm", "");
    }

    /**
     * 获取模板
     */
    private static List<String> getTemplates() {
        List<String> templates = Lists.newArrayList();
        // 后端相关模板
        templates.add("index.html.vm");
        return templates;
    }
    

    /**
     * 加载配置文件方法一  加载classpath目录下的vm文件
     */
    public static void loadTemplateFileByOne() {
        Properties p = new Properties();
        p.put("file.resource.loader.class",
                "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
        Velocity.init(p);
    }

    /**
     * 加载配置文件方法二  加载绝对路径目录下的加载vm文件
     *
     * @param templatePath 模板路径
     */
    public static void loadTemplateFileByTwo(String templatePath) {
        Properties p = new Properties();
        // 设置模板加载路径 为D盘 work文件夹
        p.setProperty(VelocityEngine.FILE_RESOURCE_LOADER_PATH, templatePath);
        Velocity.init(p);
    }

    /**
     * 加载配置文件方法三  使用配置文件
     *
     * @param propertiesPath ，如：/velocity.properties
     */
    public static void loadTemplateFileByThree(String propertiesPath) throws IOException {
        Properties p = new Properties();
        p.load(VelocityUtils.class.getClass().getResourceAsStream(propertiesPath));
        Velocity.init(p);
    }

}

html复制代码<table cellspacing="0" cellpadding="5" width="20%" >
<tr>
<td bgcolor="#eeeeee" align="center">
Names：${name}
</td>
</tr>
#foreach($name in $list)
	<tr>
	<td>
	第${velocityCount}个, 名字为  $name , 总共 ${list.size()} 个
	</td>
	</tr>
#end
</table>

html复制代码<table cellspacing="0" cellpadding="5" width="20%" >
<tr>
<td bgcolor="#eeeeee" align="center">
Names：world
</td>
</tr>
	<tr>
	<td>
	第1个, 名字为  李白 , 总共 3 个
	</td>
	</tr>
	<tr>
	<td>
	第2个, 名字为  杜甫 , 总共 3 个
	</td>
	</tr>
	<tr>
	<td>
	第3个, 名字为  陆游 , 总共 3 个
	</td>
	</tr>
</table>

csharp复制代码/**
 * 接口
 */
public interface IUserDao {

    void save();

}

csharp复制代码/**
 * 实现接口
 * 目标对象
 */
public class UserDao implements IUserDao {

    public void save() {
        System.out.println("----保存数据成功!----");
    }

}

csharp复制代码/**
 * 代理对象（静态代理）
 */
public class UserDaoProxy implements IUserDao{
    //接收保存目标对象
    private IUserDao target;
    public UserDaoProxy(IUserDao target){
        this.target=target;
    }

    public void save() {
        System.out.println("开始事务...");
        target.save();//执行目标对象的方法
        System.out.println("提交事务...");
    }
}

arduino复制代码/**
 * 测试类
 */
public class AppTest {
    public static void main(String[] args) {
        //目标对象
        UserDao target = new UserDao();

        //代理对象,把目标对象传给代理对象,建立代理关系
        UserDaoProxy proxy = new UserDaoProxy(target);

        proxy.save();//执行的是代理的方法
    }
}

scss复制代码static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h )

arduino复制代码ClassLoader loader  //指定当前目标对象使用类加载器

less复制代码Class<?>[] interfaces  //目标对象实现的接口的类型,使用泛型方式确认类型

arduino复制代码InvocationHandler h  //事件处理器

csharp复制代码/**
 * 接口
 */
public interface IUserDao {

    void save();

}

csharp复制代码/**
 * 接口实现
 * 目标对象
 */
public class UserDao implements IUserDao {

    public void save() {

        System.out.println("----保存数据成功!----");
    }

}

typescript复制代码/**
 * 创建动态代理对象
 * 动态代理不需要实现接口,但是需要指定接口类型
 */
public class ProxyFactory{

    //维护一个目标对象
    private Object target;
    public ProxyFactory(Object target){
        this.target=target;
    }

   //给目标对象生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始事务111");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务111");
                        return returnValue;
                    }
                }
        );
    }

}

scss复制代码/**
 * 测试类
 */
public class App {
    public static void main(String[] args) {
        // 目标对象
        IUserDao target = new UserDao();
        // 【原始的类型 class com.zhong.UserDao】
        System.out.println(target.getClass());

        // 给目标对象，创建代理对象
        IUserDao proxy = (IUserDao) new ProxyFactory(target).getProxyInstance();
        // class $Proxy0   内存中动态生成的代理对象
        System.out.println(proxy.getClass());

        // 执行方法   【代理对象】
        proxy.save();
    }
}

typescript复制代码//给目标对象生成代理对象
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("开始事务111");
                        //执行目标对象方法
                        Object returnValue = method.invoke(target, args);
                        System.out.println("提交事务111");
                        return returnValue;
                    }
                }
        );

java复制代码public static Object newProxyInstance(ClassLoader loader,
                                          Class>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
        //检查h 不为空，否则抛异常
        Objects.requireNonNull(h);
 
        final Class>[] intfs = interfaces.clone();
        final SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
        }
 
        /*
         * 获得与指定类装载器和一组接口相关的代理类类型对象
         */
        Class> cl = getProxyClass0(loader, intfs);
 
        /*
         * 通过反射获取构造函数对象并生成代理类实例
         */
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            //获取代理对象的构造方法（也就是$Proxy0(InvocationHandler h)） 
            final Constructor> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            //生成代理类的实例并把InvocationHandlerImpl的实例传给它的构造方法
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

csharp复制代码 /**
     * Generate a proxy class.  Must call the checkProxyAccess method
     * to perform permission checks before calling this.
     */
    private static Class> getProxyClass0(ClassLoader loader,
                                           Class>... interfaces) {
        if (interfaces.length > 65535) {
            throw new IllegalArgumentException("interface limit exceeded");
        }
 
        // If the proxy class defined by the given loader implementing
        // the given interfaces exists, this will simply return the cached copy;
        // otherwise, it will create the proxy class via the ProxyClassFactory
        return proxyClassCache.get(loader, interfaces);
    }

arduino复制代码/**
     * a cache of proxy classes
     */
    private static final WeakCache[], Class>>
        proxyClassCache = new WeakCache(new KeyFactory(), new ProxyClassFactory());

java复制代码 public synchronized V get() { // serialize access
            // re-check
            Supplier supplier = valuesMap.get(subKey);
            if (supplier != this) {
                // something changed while we were waiting:
                // might be that we were replaced by a CacheValue
                // or were removed because of failure ->
                // return null to signal WeakCache.get() to retry
                // the loop
                return null;
            }
            // else still us (supplier == this)
 
            // create new value
            V value = null;
            try {
                value = Objects.requireNonNull(valueFactory.apply(key, parameter));
            } finally {
                if (value == null) { // remove us on failure
                    valuesMap.remove(subKey, this);
                }
            }
            // the only path to reach here is with non-null value
            assert value != null;
 
            // wrap value with CacheValue (WeakReference)
            CacheValue cacheValue = new CacheValue(value);
 
            // try replacing us with CacheValue (this should always succeed)
            if (valuesMap.replace(subKey, this, cacheValue)) {
                // put also in reverseMap
                reverseMap.put(cacheValue, Boolean.TRUE);
            } else {
                throw new AssertionError("Should not reach here");
            }
 
            // successfully replaced us with new CacheValue -> return the value
            // wrapped by it
            return value;
        }
    }

java复制代码/**
     * A factory function that generates, defines and returns the proxy class given
     * the ClassLoader and array of interfaces.
     */
    private static final class ProxyClassFactory
        implements BiFunction[], Class>>
    {
        // prefix for all proxy class names
        private static final String proxyClassNamePrefix = "$Proxy";
 
        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();
 
        @Override
        public Class> apply(ClassLoader loader, Class>[] interfaces) {
 
            Map, Boolean> interfaceSet = new IdentityHashMap(interfaces.length);
            for (Class> intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                Class> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }
 
            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
 
            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
            for (Class> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }
 
            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }
 
            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
 
            /*
             * Generate the specified proxy class.
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }

ini复制代码/生成字节码
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);

ini复制代码package com.adam.java.basic;

import java.io.FileOutputStream;
import java.io.IOException;
import sun.misc.ProxyGenerator;

public class DynamicProxyTest {

    public static void main(String[] args) {

         IUserDao  userdao = new UserDao();

         ProxyFactory  handler = new  ProxyFactory  (
                userdao);

        IUserDao   proxy = (IUserDao ) handler.getProxyInstance();

        proxy.save();
        
        String path = "C:/$Proxy0.class";
        byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0",
                UserDao.class.getInterfaces());
        FileOutputStream out = null;

        try {
            out = new FileOutputStream(path);
            out.write(classFile);
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

java复制代码public final void save()
    throws 
  {
    try
    {
      this.h.invoke(this, m3, null);
      return;
    }
    catch (Error|RuntimeException localError)
    {
      throw localError;
    }
    catch (Throwable localThrowable)
    {
      throw new UndeclaredThrowableException(localThrowable);
    }
  }

swift复制代码public $Proxy0(InvocationHandler paramInvocationHandler)  
    throws   
  {  
    super(paramInvocationHandler);  

  }

vbnet复制代码static
  {
    try
    {
      m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });
      m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
      m3 = Class.forName("com.zhong.IUserDao").getMethod("save", new Class[0]);
      m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
      return;
    }

csharp复制代码/**
 * 目标对象,没有实现任何接口
 */
public class UserDao {

    public void save() {
        System.out.println("----保存数据成功!----");
    }
}

typescript复制代码/**
 * Cglib子类代理工厂
 * 对UserDao在内存中动态构建一个子类对象
 */
public class ProxyFactory implements MethodInterceptor{
    //维护目标对象
    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer en = new Enhancer();
        //2.设置父类
        en.setSuperclass(target.getClass());
        //3.设置回调函数
        en.setCallback(this);
        //4.创建子类(代理对象)
        return en.create();

    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("开始事务...");

        //执行目标对象的方法
        Object returnValue = method.invoke(target, args);

        System.out.println("提交事务...");

        return returnValue;
    }
}

java复制代码/**
 * 测试类
 */
public class AppTest {

    @Test
    public void test(){
        //目标对象
        UserDao target = new UserDao();

        //代理对象
        UserDao proxy = (UserDao)new ProxyFactory(target).getProxyInstance();

        //执行代理对象的方法
        proxy.save();
    }
}

makefile复制代码现在C:\Windows\Fonts 中搜索 STSONG.TTF 复制到其他目录中（直接在这个目录找不到字体文件）
在 jasperreports studio中添加字体 windows -> preferences

xml复制代码<?xml version="1.0" encoding="UTF-8"?>
<fontFamilies>
    <fontFamily name="华文宋体">
        <normal>jasperreport/fonts/STSONG.TTF</normal>
        <bold>jasperreport/fonts/STSONG.TTF</bold>
        <italic>jasperreport/fonts/STSONG.TTF</italic>
        <boldItalic>jasperreport/fonts/STSONG.TTF</boldItalic>
        <pdfEncoding>Identity-H</pdfEncoding>
        <pdfEmbedded>true</pdfEmbedded>
        <exportFonts>
            <export key="net.sf.jasperreports.html">'华文宋体', Arial, Helvetica, sans-serif</export>
            <export key="net.sf.jasperreports.xhtml">'华文宋体', Arial, Helvetica, sans-serif</export>
        </exportFonts>
    </fontFamily>
</fontFamilies>

复制代码2.1 中在 windows fonts 中粘贴出来的字体

ini复制代码net.sf.jasperreports.extension.registry.factory.simple.font.families=net.sf.jasperreports.engine.fonts.SimpleFontExtensionsRegistryFactory
net.sf.jasperreports.extension.simple.font.families.lobstertwo=jasperreport/fonts/fonts.xml

ini复制代码Map<String, Object> paramMap = getMapData();
JRBeanCollectionDataSource dataSource = new JRBeanCollectionDataSource(getEntities());
ClassPathResource resource = new ClassPathResource(TEMPLATE_PATH + "StudentDetails.jasper");
try {
    InputStream inputStream = resource.getInputStream();
    // 详情 + 表头
    JasperPrint jasperPrint = JasperFillManager.fillReport(inputStream, paramMap, dataSource);
    byte[] bytes = JasperExportManager.exportReportToPdf(jasperPrint);
    FileOutputStream outFile = new FileOutputStream(FILE_PATH);
    outFile.write(bytes);
    outFile.close();
} catch (JRException | IOException e) {
    e.printStackTrace();
}

go复制代码	key = consts.ValidatorPrefix + "UsersRegister"
	containers.Set(key, users.Register{})

go复制代码// 给出一些最常用的验证规则：
//required  必填；
//len=11 长度=11；
//min=3  如果是数字，验证的是数据范围，最小值为3，如果是文本，验证的是最小长度为3，
//max=6 如果是数字，验证的是数字最大值为6，如果是文本，验证的是最大长度为6
// mail 验证邮箱
//gt=3  对于文本就是长度>=3
//lt=6  对于文本就是长度<=6

type Register struct {
	BaseField
	// 表单参数验证结构体支持匿名结构体嵌套、以及匿名结构体与普通字段组合
	Phone  string `form:"phone" json:"phone"`     // 手机号， 非必填
	CardNo string `form:"card_no" json:"card_no"` //身份证号码，非必填
}

// 特别注意: 表单参数验证器结构体的函数，绝对不能绑定在指针上
// 我们这部分代码项目启动后会加载到容器，如果绑定在指针，一次请求之后，会造成容器中的代码段被污染

func (r Register) CheckParams(context *gin.Context) {
	//1.先按照验证器提供的基本语法，基本可以校验90%以上的不合格参数
	if err := context.ShouldBind(&r); err != nil {
		errs := gin.H{
			"tips": "UserRegister参数校验失败，参数不符合规定，user_name 长度(>=1)、pass长度[6,20]、不允许注册",
			"err":  err.Error(),
		}
		response.ErrorParam(context, errs)
		return
	}
	//2.继续验证具有中国特色的参数，例如 身份证号码等，基本语法校验了长度18位，然后可以自行编写正则表达式等更进一步验证每一部分组成
	// r.CardNo  获取值继续校验，这里省略.....

	//  该函数主要是将本结构体的字段（成员）按照 consts.ValidatorPrefix+ json标签对应的 键 => 值 形式绑定在上下文，便于下一步（控制器）可以直接通过 context.Get(键) 获取相关值
	extraAddBindDataContext := data_transfer.DataAddContext(r, consts.ValidatorPrefix, context)
	if extraAddBindDataContext == nil {
		response.ErrorSystem(context, "UserRegister表单验证器json化失败", "")
	} else {
		// 验证完成，调用控制器,并将验证器成员(字段)递给控制器，保持上下文数据一致性
		(&web.Users{}).Register(extraAddBindDataContext)
	}

}

go复制代码func Create(key string) func(context *gin.Context) {
	//通过键key取出验证器对象。
	if value := container.CreateContainersFactory().Get(key); value != nil {
		//通过断言拿到对象
		if val, isOk := value.(interf.ValidatorInterface); isOk {
			return val.CheckParams
		}
	}
	variable.ZapLog.Error(my_errors.ErrorsValidatorNotExists + ", 验证器模块：" + key)
	return nil
}

go复制代码(&web.Users{}).Register(extraAddBindDataContext)

go复制代码	userName := context.GetString(consts.ValidatorPrefix + "user_name")
	pass := context.GetString(consts.ValidatorPrefix + "pass")
	userIp := context.ClientIP()

ini复制代码[request_definition]
r = sub, obj, act

ini复制代码[policy_definition]
p = sub, obj, act，(eft)

ini复制代码[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act

ini复制代码[role_definition]
g = _, _

ini复制代码[request_definition]
r = sub, dom, obj, act

[policy_definition]
p = sub, dom, obj, act

[role_definition]
g = _, _, _

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = g(r.sub, p.sub, r.dom) && r.dom == p.dom && r.obj == p.obj && r.act == p.act

java复制代码public class ByteBufStudy {
    public static void main(String[] args) {
        // 创建ByteBuf
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16);
        ByteBufUtil.log(buffer);

        // 向buffer中写入数据
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < 20; i++) {
            sb.append("a");
        }
        buffer.writeBytes(sb.toString().getBytes(StandardCharsets.UTF_8));

        // 查看写入结果
        ByteBufUtil.log(buffer);
    }
}

java复制代码ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16);

java复制代码ByteBuf buffer = ByteBufAllocator.DEFAULT.heapBuffer(16);

java复制代码ByteBuf buffer = ByteBufAllocator.DEFAULT.directBuffer(16);

java复制代码public class ByteBufStudy {
    public static void main(String[] args) {
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16);
        System.out.println(buffer.getClass());

        buffer = ByteBufAllocator.DEFAULT.heapBuffer(16);
        System.out.println(buffer.getClass());

        buffer = ByteBufAllocator.DEFAULT.directBuffer(16);
        System.out.println(buffer.getClass());
    }
}

arduino复制代码// 使用池化的直接内存
class io.netty.buffer.PooledUnsafeDirectByteBuf
    
// 使用池化的堆内存    
class io.netty.buffer.PooledUnsafeHeapByteBuf
    
// 使用池化的直接内存    
class io.netty.buffer.PooledUnsafeDirectByteBuf

java复制代码public class test {

    public static void main(String[] args) {
        // 创建ByteBuf
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16, 20);

        // 向buffer中写入byte类型，1字节大小
        buffer.writeBytes(new byte[]{1, 2, 3, 4});
		// 向buffer中写入int类型，4字节大小
        buffer.writeInt(5);
		// 向buffer中小端写入int类型，4字节大小
        buffer.writeIntLE(6);
		// 向buffer中写入long类型，8字节大小
        buffer.writeLong(7);
        log(buffer);
    }

    private static void log(ByteBuf buffer) {
        //ByteBuf 可视化
        int length = buffer.readableBytes();
        int rows = length / 16 + (length % 15 == 0 ? 0 : 1) + 4;
        StringBuilder buf = new StringBuilder(rows * 80 * 2)
                .append("read index:").append(buffer.readerIndex())
                .append(" write index:").append(buffer.writerIndex())
                .append(" capacity:").append(buffer.capacity())
                .append(NEWLINE);
        appendPrettyHexDump(buf, buffer);
        System.out.println(buf.toString());
    }
}

perl复制代码buffer.writeLong(7);
log(buffer);

// 扩容前
read index:0 write index:12 capacity:16
...

// 扩容后
read index:0 write index:20 capacity:20
         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000000| 01 02 03 04 00 00 00 05 06 00 00 00 00 00 00 00 |................|
|00000010| 00 00 00 07                                     |....            |
+--------+-------------------------------------------------+----------------+

java复制代码public static void main(String[] args) {
        // 创建ByteBuf
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16, 20);

        // 向buffer中写入数据
        buffer.writeBytes(new byte[]{1, 2, 3, 4});
        buffer.writeInt(5);
        ByteBufferUtil.log(buffer);

        // 读取4个字节
        System.out.println(buffer.readByte());
        System.out.println(buffer.readByte());
        System.out.println(buffer.readByte());
        System.out.println(buffer.readByte());
        ByteBufferUtil.log(buffer);

        // 通过mark与reset实现重复读取
        buffer.markReaderIndex();
        System.out.println(buffer.readInt());
        ByteBufferUtil.log(buffer);

        // 恢复到mark标记处
        buffer.resetReaderIndex();
        ByteBufferUtil.log(buffer);
    }

java复制代码public static void main(String[] args) {
        // 创建ByteBuf
        ByteBuf buffer = ByteBufAllocator.DEFAULT.buffer(16, 20);

        // 向buffer中写入数据
        buffer.writeBytes(new byte[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10});

        // 将buffer分成两部分，参数：start，length，在切片过程中没有发生数据复制，同一块内存
        ByteBuf slice1 = buffer.slice(0, 5);
        ByteBuf slice2 = buffer.slice(5, 5);

        // 需要让分片的buffer引用计数加一
        // 避免原Buffer释放导致分片buffer无法使用
        slice1.retain();
        slice2.retain();

        ByteBufferUtil.log(slice1);
        ByteBufferUtil.log(slice2);

        // 更改原始buffer中的值
        System.out.println("===========修改原buffer中的值===========");
        buffer.setByte(0,5);

        System.out.println("===========打印slice1===========");
        ByteBufferUtil.log(slice1);
    }

ini复制代码#获取商品库存信息             
local counts = redis.call("HMGET", KEYS[1], "total", "ordered"); #将总库存转换为数值 
local total = tonumber(counts[1]) #将已被秒杀的库存转换为数值 
local ordered = tonumber(counts[2])   #如果当前请求的库存量加上已被秒杀的库存量仍然小于总库存量，就可以更新库存          
if ordered + k <= total then     #更新已秒杀的库存量     redis.call("HINCRBY",KEYS[1],"ordered",k)                              
return k;   
end                
return 0