精华内容
下载资源
问答
  • #资源达人分享计划#
  • 行业资料-交通装置-一种后背式汽车进气引入管总成.zip
  • 行业资料-电子功用-气体激光电源引入结构
  • 引入金融背景高人员与企业资本结构调整
  • 引入制动路约束的车辆操纵稳定性控制方法研究,王宪彬,邓红星,本文以DYC (Direct Yaw-moment Control)控制器为基础,结合制动路摩擦力模型的约束条件,建立了全轮纵向力优化分配算法。利用MATLAB软件�
  • 电子政务-提高稳压的电压并引入温度补偿的装置.zip
  • 为实现碳纳米和乳糖的相互化学修饰,使之成为一类具有生物活性的新物质.先用草酰氯和偶氮二异丁腈(AIBN)分别将碳纳米羧酸化,再将乳糖酸与乙二胺反应.将新得到的2种经过化学修饰的产物进行反应,得到负载N-...
  • 这里是相关的一些工具jar包:链接:http://pan.baidu.com/s/1qYgyNTi 密码:o8ig
    需要修改class文件里几个文本,但是里面import了很多其他类,不能直接反编译改了再编译,网上看到个用了下成功了,记录下备用


    直接修改别人jar包里面的class文件 工具:jclasslib

    软件安装: 把jclasslib 下载下来安装好 (我下的是3.0的,百度google很多..)

    我这里以我自己写的一个小工具 POJOTool.jar 为例

    软件打开画面效果如下

    比如我想要修改 不能链接数据库的提示信息 为 "芝麻不开门!"

     

    步骤如下:

    1.用jd-gui打开该jar  怎么打开不用我说了吧?

    打开之后找到 要修改提示信息 的class文件 这里找到的是GenEntity

    找到对应需要修改的代码所在的方法名

    我这里包含提示信息的这段代码在方法 getAllDataBase()  如下图:

    2.用jd-gui或者winrar把GenEntity.class 解压出来到C盘 (目录无所谓)

    3.双击桌面上安装好了的 jclasslib bytecode viewer ,点击软件的 File -- Open Class File 打开你刚解压出来的class文件

    4.点击methods--getAllDataBase--Code

    methods是表示方法不用说吧

    getAllDataBase是刚在jd-gui里面找到的方法名

    Code包含了getAllDataBase方法里所有的信息

    找到"不能打开数据库连接,请检查!"

    这里这个工具没有提供搜索功能

    如果这里很多内容 那么你可以点击 copy to clipboard把这里的内容复制到一个文本文件里面然后再搜索

     

     

    这里找到的是第82行

     

    5.点击第 82行后面的 #34 会跳转到Constant Pool常量池的第34个常量

    6.再点右边的 cp info #362 会跳转到第362个常量

    这里能看到String: 不能打开数据库连接,请检查! 也就是最后输出的信息

    7.找到GenEntity.class的关键常量了现在就该修改它了

    在eclipse里面新建一个Test来处理GenEntity.class

    [java]  view plain  copy
    1. import java.io.*;     
    2. import org.gjt.jclasslib.io.ClassFileWriter;     
    3. import org.gjt.jclasslib.structures.CPInfo;     
    4. import org.gjt.jclasslib.structures.ClassFile;     
    5. import org.gjt.jclasslib.structures.constants.ConstantUtf8Info;     
    6. public class Test {     
    7.     public static void main(String[] args) throws Exception {     
    8.     
    9.         String filePath = "C:\\GenEntity.class";     
    10.         FileInputStream fis = new FileInputStream(filePath);     
    11.              
    12.         DataInput di = new DataInputStream(fis);     
    13.         ClassFile cf = new ClassFile();     
    14.         cf.read(di);     
    15.         CPInfo[] infos = cf.getConstantPool();     
    16.              
    17.         int count = infos.length;     
    18.         for (int i = 0; i < count; i++) {     
    19.             if (infos[i] != null) {     
    20.                 System.out.print(i);     
    21.                 System.out.print(" = ");     
    22.                 System.out.print(infos[i].getVerbose());     
    23.                 System.out.print(" = ");     
    24.                 System.out.println(infos[i].getTagVerbose());     
    25.                 if(i == 362){     
    26.                     ConstantUtf8Info uInfo = (ConstantUtf8Info)infos[i];     
    27.                     uInfo.setBytes("芝麻不开门!".getBytes());     
    28.                     infos[i]=uInfo;     
    29.                 }     
    30.             }     
    31.         }     
    32.         cf.setConstantPool(infos);     
    33.         fis.close();     
    34.         File f = new File(filePath);     
    35.         ClassFileWriter.writeToFile(f, cf);     
    36.     }     
    37. }    


    这里需要注意"C:\\GenEntity.class"是我存放class的目录


    if(i == 362) 这里是刚我在第七步找到的常量序号


    "芝麻不开门!"这里是我想修改的文字信息!

    运行Test.java 会有如下提示信息 没有报错就证明正常的 如果报错那么就有问题

    9.把C盘刚修改后的GenEntity.class替换掉原来的GenEntity.class

    怎么替换不用我说了吧..

    用winrar打开.jar 然后把GenEntity.class拖进去覆盖就行了

    10.运行效果..

    大功告成...

    老大 

    直接修改别人jar包里面的class文件 工具:jclasslib


     

    需要把别人jar包里面的class修改一下信息

    配置文件*.properties MANIFEST.MF 这些东西可以直接用记事本打开修改 然后替换掉就OK..

    在网上游荡了半天,没有找到合适的方法

    开始我是先用jd-gui反编译 把我需要修改的那个A.class文件反编译出来把代码保存到A.Java

    然后直接在dos里面用javac A.java编译

    问题来了..

    因为A.java引用了很多其他jar下面的方法 而且A.java有package

    鼓捣了半天以后 最终结果:编译无法正常通过 不能达到直接修改替换掉别人的class文件的目的

    于是又在网上转悠

    看到jclasslib这个东西 于是又鼓捣了一会儿

    居然成功了 窃喜 遂记下步骤方法 提供给需要的朋友..

    软件安装: 把jclasslib 下载下来安装好 (我下的是3.0的,百度google很多..)

    我这里以我自己写的一个小工具 POJOTool.jar 为例

    软件打开画面效果如下

    比如我想要修改 不能链接数据库的提示信息 为 "芝麻不开门!"

     

    步骤如下:

    1.用jd-gui打开该jar  怎么打开不用我说了吧?

    打开之后找到 要修改提示信息 的class文件 这里找到的是GenEntity

    找到对应需要修改的代码所在的方法名

    我这里包含提示信息的这段代码在方法 getAllDataBase()  如下图:

    2.用jd-gui或者winrar把GenEntity.class 解压出来到C盘 (目录无所谓)

    3.双击桌面上安装好了的 jclasslib bytecode viewer ,点击软件的 File -- Open Class File 打开你刚解压出来的class文件

    4.点击methods--getAllDataBase--Code

    methods是表示方法不用说吧

    getAllDataBase是刚在jd-gui里面找到的方法名

    Code包含了getAllDataBase方法里所有的信息

    找到"不能打开数据库连接,请检查!"

    这里这个工具没有提供搜索功能

    如果这里很多内容 那么你可以点击 copy to clipboard把这里的内容复制到一个文本文件里面然后再搜索

     

     

    这里找到的是第82行

     

    5.点击第 82行后面的 #34 会跳转到Constant Pool常量池的第34个常量

    6.再点右边的 cp info #362 会跳转到第362个常量

    这里能看到String: 不能打开数据库连接,请检查! 也就是最后输出的信息

    7.找到GenEntity.class的关键常量了现在就该修改它了

    在eclipse里面新建一个Test来处理GenEntity.class

    [java]  view plain  copy
    1. import java.io.*;     
    2. import org.gjt.jclasslib.io.ClassFileWriter;     
    3. import org.gjt.jclasslib.structures.CPInfo;     
    4. import org.gjt.jclasslib.structures.ClassFile;     
    5. import org.gjt.jclasslib.structures.constants.ConstantUtf8Info;     
    6. public class Test {     
    7.     public static void main(String[] args) throws Exception {     
    8.     
    9.         String filePath = "C:\\GenEntity.class";     
    10.         FileInputStream fis = new FileInputStream(filePath);     
    11.              
    12.         DataInput di = new DataInputStream(fis);     
    13.         ClassFile cf = new ClassFile();     
    14.         cf.read(di);     
    15.         CPInfo[] infos = cf.getConstantPool();     
    16.              
    17.         int count = infos.length;     
    18.         for (int i = 0; i < count; i++) {     
    19.             if (infos[i] != null) {     
    20.                 System.out.print(i);     
    21.                 System.out.print(" = ");     
    22.                 System.out.print(infos[i].getVerbose());     
    23.                 System.out.print(" = ");     
    24.                 System.out.println(infos[i].getTagVerbose());     
    25.                 if(i == 362){     
    26.                     ConstantUtf8Info uInfo = (ConstantUtf8Info)infos[i];     
    27.                     uInfo.setBytes("芝麻不开门!".getBytes());     
    28.                     infos[i]=uInfo;     
    29.                 }     
    30.             }     
    31.         }     
    32.         cf.setConstantPool(infos);     
    33.         fis.close();     
    34.         File f = new File(filePath);     
    35.         ClassFileWriter.writeToFile(f, cf);     
    36.     }     
    37. }    


    这里需要注意"C:\\GenEntity.class"是我存放class的目录


    if(i == 362) 这里是刚我在第七步找到的常量序号


    "芝麻不开门!"这里是我想修改的文字信息!

    运行Test.java 会有如下提示信息 没有报错就证明正常的 如果报错那么就有问题

    9.把C盘刚修改后的GenEntity.class替换掉原来的GenEntity.class

    怎么替换不用我说了吧..

    用winrar打开.jar 然后把GenEntity.class拖进去覆盖就行了

    10.运行效果..

    大功告成...

    展开全文
  • 我们报告了基于并五苯有机薄膜晶体(OTFT)的改进的无标签DNA传感器。 首先以并五苯作为活性层制备了具有顶部接触结构的OTFT。 在单链DNA(ssDNA)固定过程中,OTFT的源极和栅极触点之间引入了不同的电偏压,以...
  • 不用它,直接 y 这时会下载element 下载完成之后会提示你是完全引入还是按需引入。完全引入的话会使我们的包变大,因为这里边很多组件在我们实际项目中都用不到。所以我们选择按需引入,如下图 第三步: 第四步...

    按需引入

    在使用element-ui时绝大多数情况,我们都是按需引入,我来总结一下如何按需引入

    tips:

    当我们在已有的项目中安装时,需要注意安装完毕后会改变app.vue页面,大家记得提前复制一份,最后再把原来的粘贴一下就行,否则会报错误。

    第一步:

    vue add element
    

    第二步:

    这时会出现这个提醒

    11

    他是意思是:当前存储库中有未提交的更改,建议提交 或者先藏起来。不用管它,直接 y
    这时会下载element

    11

    下载完成之后会提示你是完全引入还是按需引入。完全引入的话会使我们的包变大,因为这里边很多组件在我们实际项目中都用不到。所以我们选择按需引入,如下图

    第三步:

    11
    第四步:选择要加载的区域设置

    11

    这样我们就按需引用完毕了。这时我们会发现我们的src文件夹中多了一个plugins文件夹,文件夹中有一个element.js文件。这时先不要急着运行,安装完element,我们的app.vue会发生改变,先把不需要的删除了(如果我们的项目在正在运行的状态,安装好需要重新启动)

    第五步:运行:npm run serve

    这时我们就可以得到一个基本的element-ui组件button了。

    11

    当我们想再引入别的组件时(在element.js文件中),比如input:这里边有一个小技巧,就是判断我们引入的时候,输入的是不是有问题,当我们开始输入的时候,如果下边有补充,说明没有问题,如果没有,你就要想想了

    11
    正确引用需要使用Vue.use来进行全局注册

    import Vue from 'vue'
    import { Button,Input} from 'element-ui'
    
    
    Vue.use(Button)
    Vue.use(Input)
    
    

    这时,我们就可以看到效果:

    11

    引入element-ui方法的方式

    第一种:全局引入

    比如在Message 消息提示中需要使用一个message方法,我们就需要引入,引入放入与组件差不多
    import Vue from 'vue'
    import { Button,Input,Message} from 'element-ui'
    
    Vue.prototype.$message = Message;
    Vue.use(Button)
    Vue.use(Input)
    
    我们在点击按钮时出发一个open事件,在methods写方法就可以直接使用
    methods:{
        open(){
          this.$message('这是一条消息提示');
        }
      }
    

    效果:
    11
    第二种:局部引入

    import{ Message} from "element-ui"
    export default {
      name: 'app',
      data() {
        return {
          input: ""
        }
      },
      methods:{
        open(){
          Message('这是一条消息提示');
        }
      }
    }
    
    展开全文
  • 1.5.3 访指令与访中断

    万次阅读 多人点赞 2016-06-19 22:57:22
    访指令是一条可以在用户态下执行的指令。...为什么要在程序中引入访指令呢?这是因为用户程序只能在用户态下运行,如果用户程序想要完成用户态下无法完成的工作,该怎么办呢?解决这个问题要靠访指令。访 指令本

    访管指令是一条可以在用户态下执行的指令。在用户程序中,因要求操作系统提供服务而有意识地使用访管指令,从而产生一个中断事件(自愿中断),将操作系统转换为核心态,称为访管中断。访管中断由访管指令产生,程序员使用访管指令向操作系统请求服务。

    为什么要在程序中引入访管指令呢?这是因为用户程序只能在用户态下运行,如果用户程序想要完成用户态下无法完成的工作,该怎么办呢?解决这个问题要靠访管指令。访管 指令本身不是特权指令,其基本功能是让程序拥有“自愿进管”的手段,从而引起访管中断。

    当处于 用户态的用户程序使用访管指令时,系统根据访管指令的操作数执行访管中断处理程序,访管中断处理程序将按系统 调用的操作数和参数转到相应的例行子程序。完成服务功能后,退出中断,返回到用户程序断点继续执行。

    展开全文
  • Redis API 必杀解读:引入RedisTemplate

    万次阅读 2017-08-18 16:20:34
    题记在工作和学习中啊,比如说JAVA开发,要使用Redis,首先要引入一个RedisTemplate类// // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) //package org....

    题记

    在工作和学习中啊,比如说JAVA开发,要使用Redis,首先要引入一个RedisTemplate类.
    在此,将所有的方法都已经注释出来了.

    //
    // Source code recreated from a .class file by IntelliJ IDEA
    // (powered by Fernflower decompiler)
    //
    
    package org.springframework.data.redis.core;
    
    import java.io.Closeable;
    import java.lang.reflect.Proxy;
    import java.util.ArrayList;
    import java.util.Collection;
    import java.util.Collections;
    import java.util.Date;
    import java.util.Iterator;
    import java.util.LinkedHashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    import org.springframework.beans.factory.BeanClassLoaderAware;
    import org.springframework.dao.DataAccessException;
    import org.springframework.dao.InvalidDataAccessApiUsageException;
    import org.springframework.data.redis.connection.DataType;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.connection.SortParameters;
    import org.springframework.data.redis.connection.RedisZSetCommands.Tuple;
    import org.springframework.data.redis.core.ZSetOperations.TypedTuple;
    import org.springframework.data.redis.core.query.QueryUtils;
    import org.springframework.data.redis.core.query.SortQuery;
    import org.springframework.data.redis.core.script.DefaultScriptExecutor;
    import org.springframework.data.redis.core.script.RedisScript;
    import org.springframework.data.redis.core.script.ScriptExecutor;
    import org.springframework.data.redis.core.types.RedisClientInfo;
    import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;
    import org.springframework.data.redis.serializer.RedisSerializer;
    import org.springframework.data.redis.serializer.SerializationUtils;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    import org.springframework.transaction.support.TransactionSynchronizationManager;
    import org.springframework.util.Assert;
    import org.springframework.util.ClassUtils;
    import org.springframework.util.CollectionUtils;
    
    public class RedisTemplate<K, V> extends RedisAccessor implements RedisOperations<K, V>, BeanClassLoaderAware {
        private boolean enableTransactionSupport = false;
        private boolean exposeConnection = false;
        private boolean initialized = false;
        private boolean enableDefaultSerializer = true;
        private RedisSerializer<?> defaultSerializer;
        private ClassLoader classLoader;
        private RedisSerializer keySerializer = null;
        private RedisSerializer valueSerializer = null;
        private RedisSerializer hashKeySerializer = null;
        private RedisSerializer hashValueSerializer = null;
        private RedisSerializer<String> stringSerializer = new StringRedisSerializer();
        private ScriptExecutor<K> scriptExecutor;
        private ValueOperations<K, V> valueOps;
        private ListOperations<K, V> listOps;
        private SetOperations<K, V> setOps;
        private ZSetOperations<K, V> zSetOps;
        private GeoOperations<K, V> geoOps;
        private HyperLogLogOperations<K, V> hllOps;
    
        public RedisTemplate() {
        }
    
        //afterPropertiesSet (初始化操作)加载配置后执行
        public void afterPropertiesSet() {
            super.afterPropertiesSet();
            boolean defaultUsed = false;
            //serializer 序列化
            if (this.defaultSerializer == null) {
                this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader());
            }
            //enable 使能够,提供做…的权利[措施]; 使可能; 授予权利或方法;
            if (this.enableDefaultSerializer) {
                if (this.keySerializer == null) {
                    this.keySerializer = this.defaultSerializer;
                    defaultUsed = true;
                }
    
                if (this.valueSerializer == null) {
                    this.valueSerializer = this.defaultSerializer;
                    defaultUsed = true;
                }
    
                if (this.hashKeySerializer == null) {
                    this.hashKeySerializer = this.defaultSerializer;
                    defaultUsed = true;
                }
    
                if (this.hashValueSerializer == null) {
                    this.hashValueSerializer = this.defaultSerializer;
                    defaultUsed = true;
                }
            }
    
            if (this.enableDefaultSerializer && defaultUsed) {
                Assert.notNull(this.defaultSerializer, "default serializer null and not all serializers initialized");
            }
    
            //script脚本
            //Executor 遗嘱执行人; 执行者; 实行者;
            if (this.scriptExecutor == null) {
                this.scriptExecutor = new DefaultScriptExecutor(this);
            }
            //初始化完成
            this.initialized = true;
        }
    
        //execute 执行   exposeConnection暴露连接
        public <T> T execute(RedisCallback<T> action) {
            return this.execute(action, this.isExposeConnection());
        }
    
        public <T> T execute(RedisCallback<T> action, boolean exposeConnection) {
            return this.execute(action, exposeConnection, false);
        }
    
        //pipeline 管道
        public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
            Assert.isTrue(this.initialized, "template not initialized; call afterPropertiesSet() before using it");
            Assert.notNull(action, "Callback object must not be null");
            RedisConnectionFactory factory = this.getConnectionFactory();
            RedisConnection conn = null;
    
            Object var11;
            try {
                //enableTransactionSupport 是否支持事务
                if (this.enableTransactionSupport) {
                    conn = RedisConnectionUtils.bindConnection(factory, this.enableTransactionSupport);
                } else {
                    conn = RedisConnectionUtils.getConnection(factory);
                }
    
                //现存的; 目前的;
                boolean existingConnection = TransactionSynchronizationManager.hasResource(factory);
                RedisConnection connToUse = this.preProcessConnection(conn, existingConnection);
                boolean pipelineStatus = connToUse.isPipelined();
                if (pipeline && !pipelineStatus) {
                    connToUse.openPipeline();
                }
    
                RedisConnection connToExpose = exposeConnection ? connToUse : this.createRedisConnectionProxy(connToUse);
                T result = action.doInRedis(connToExpose);
                if (pipeline && !pipelineStatus) {
                    connToUse.closePipeline();
                }
    
                var11 = this.postProcessResult(result, connToUse, existingConnection);
            } finally {
                RedisConnectionUtils.releaseConnection(conn, factory);
            }
    
            return var11;
        }
    
        public <T> T execute(SessionCallback<T> session) {
            Assert.isTrue(this.initialized, "template not initialized; call afterPropertiesSet() before using it");
            Assert.notNull(session, "Callback object must not be null");
            RedisConnectionFactory factory = this.getConnectionFactory();
            RedisConnectionUtils.bindConnection(factory, this.enableTransactionSupport);
    
            Object var3;
            try {
                var3 = session.execute(this);
            } finally {
                RedisConnectionUtils.unbindConnection(factory);
            }
    
            return var3;
        }
    
        //executePipelined 执行管道
        public List<Object> executePipelined(SessionCallback<?> session) {
            return this.executePipelined(session, this.valueSerializer);
        }
    
        public List<Object> executePipelined(final SessionCallback<?> session, final RedisSerializer<?> resultSerializer) {
            Assert.isTrue(this.initialized, "template not initialized; call afterPropertiesSet() before using it");
            Assert.notNull(session, "Callback object must not be null");
            RedisConnectionFactory factory = this.getConnectionFactory();
            RedisConnectionUtils.bindConnection(factory, this.enableTransactionSupport);
    
            List var4;
            try {
                var4 = (List)this.execute(new RedisCallback<List<Object>>() {
                    public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
                        connection.openPipeline();
                        boolean pipelinedClosed = false;
    
                        List var5;
                        try {
                            Object result = RedisTemplate.this.executeSession(session);
                            if (result != null) {
                                throw new InvalidDataAccessApiUsageException("Callback cannot return a non-null value as it gets overwritten by the pipeline");
                            }
    
                            List<Object> closePipeline = connection.closePipeline();
                            pipelinedClosed = true;
                            var5 = RedisTemplate.this.deserializeMixedResults(closePipeline, resultSerializer, RedisTemplate.this.hashKeySerializer, RedisTemplate.this.hashValueSerializer);
                        } finally {
                            if (!pipelinedClosed) {
                                connection.closePipeline();
                            }
    
                        }
    
                        return var5;
                    }
                });
            } finally {
                RedisConnectionUtils.unbindConnection(factory);
            }
    
            return var4;
        }
    
        public List<Object> executePipelined(RedisCallback<?> action) {
            return this.executePipelined(action, this.valueSerializer);
        }
    
        public List<Object> executePipelined(final RedisCallback<?> action, final RedisSerializer<?> resultSerializer) {
            return (List)this.execute(new RedisCallback<List<Object>>() {
                public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.openPipeline();
                    boolean pipelinedClosed = false;
    
                    List var5;
                    try {
                        Object result = action.doInRedis(connection);
                        if (result != null) {
                            throw new InvalidDataAccessApiUsageException("Callback cannot return a non-null value as it gets overwritten by the pipeline");
                        }
    
                        List<Object> closePipeline = connection.closePipeline();
                        pipelinedClosed = true;
                        var5 = RedisTemplate.this.deserializeMixedResults(closePipeline, resultSerializer, RedisTemplate.this.hashKeySerializer, RedisTemplate.this.hashValueSerializer);
                    } finally {
                        if (!pipelinedClosed) {
                            connection.closePipeline();
                        }
    
                    }
    
                    return var5;
                }
            });
        }
    
        public <T> T execute(RedisScript<T> script, List<K> keys, Object... args) {
            return this.scriptExecutor.execute(script, keys, args);
        }
    
        public <T> T execute(RedisScript<T> script, RedisSerializer<?> argsSerializer, RedisSerializer<T> resultSerializer, List<K> keys, Object... args) {
            return this.scriptExecutor.execute(script, argsSerializer, resultSerializer, keys, args);
        }
    
        public <T extends Closeable> T executeWithStickyConnection(RedisCallback<T> callback) {
            Assert.isTrue(this.initialized, "template not initialized; call afterPropertiesSet() before using it");
            Assert.notNull(callback, "Callback object must not be null");
            RedisConnectionFactory factory = this.getConnectionFactory();
            RedisConnection connection = this.preProcessConnection(RedisConnectionUtils.doGetConnection(factory, true, false, false), false);
            return (Closeable)callback.doInRedis(connection);
        }
    
        //Session会话
        private Object executeSession(SessionCallback<?> session) {
            return session.execute(this);
        }
    
        //Proxy 代理服务器; 代表权; 代理人,代替物; 委托书;
        protected RedisConnection createRedisConnectionProxy(RedisConnection pm) {
            Class<?>[] ifcs = ClassUtils.getAllInterfacesForClass(pm.getClass(), this.getClass().getClassLoader());
            return (RedisConnection)Proxy.newProxyInstance(pm.getClass().getClassLoader(), ifcs, new CloseSuppressingInvocationHandler(pm));
        }
    
        protected RedisConnection preProcessConnection(RedisConnection connection, boolean existingConnection) {
            return connection;
        }
    
        protected <T> T postProcessResult(T result, RedisConnection conn, boolean existingConnection) {
            return result;
        }
    
        public boolean isExposeConnection() {
            return this.exposeConnection;
        }
    
        public void setExposeConnection(boolean exposeConnection) {
            this.exposeConnection = exposeConnection;
        }
    
        //是否默认序列化
        public boolean isEnableDefaultSerializer() {
            return this.enableDefaultSerializer;
        }
    
        public void setEnableDefaultSerializer(boolean enableDefaultSerializer) {
            this.enableDefaultSerializer = enableDefaultSerializer;
        }
    
        public RedisSerializer<?> getDefaultSerializer() {
            return this.defaultSerializer;
        }
    
        public void setDefaultSerializer(RedisSerializer<?> serializer) {
            this.defaultSerializer = serializer;
        }
    
        public void setKeySerializer(RedisSerializer<?> serializer) {
            this.keySerializer = serializer;
        }
    
        public RedisSerializer<?> getKeySerializer() {
            return this.keySerializer;
        }
    
        public void setValueSerializer(RedisSerializer<?> serializer) {
            this.valueSerializer = serializer;
        }
    
        public RedisSerializer<?> getValueSerializer() {
            return this.valueSerializer;
        }
    
        public RedisSerializer<?> getHashKeySerializer() {
            return this.hashKeySerializer;
        }
    
        public void setHashKeySerializer(RedisSerializer<?> hashKeySerializer) {
            this.hashKeySerializer = hashKeySerializer;
        }
    
        public RedisSerializer<?> getHashValueSerializer() {
            return this.hashValueSerializer;
        }
    
        public void setHashValueSerializer(RedisSerializer<?> hashValueSerializer) {
            this.hashValueSerializer = hashValueSerializer;
        }
    
        public RedisSerializer<String> getStringSerializer() {
            return this.stringSerializer;
        }
    
        public void setStringSerializer(RedisSerializer<String> stringSerializer) {
            this.stringSerializer = stringSerializer;
        }
    
        public void setScriptExecutor(ScriptExecutor<K> scriptExecutor) {
            this.scriptExecutor = scriptExecutor;
        }
    
        private byte[] rawKey(Object key) {
            Assert.notNull(key, "non null key required");
            return this.keySerializer == null && key instanceof byte[] ? (byte[])((byte[])key) : this.keySerializer.serialize(key);
        }
    
        private byte[] rawString(String key) {
            return this.stringSerializer.serialize(key);
        }
    
        private byte[] rawValue(Object value) {
            return this.valueSerializer == null && value instanceof byte[] ? (byte[])((byte[])value) : this.valueSerializer.serialize(value);
        }
    
        private byte[][] rawKeys(Collection<K> keys) {
            byte[][] rawKeys = new byte[keys.size()][];
            int i = 0;
    
            Object key;
            for(Iterator var4 = keys.iterator(); var4.hasNext(); rawKeys[i++] = this.rawKey(key)) {
                key = var4.next();
            }
    
            return rawKeys;
        }
    
        //deserializeKey 反序列化
        private K deserializeKey(byte[] value) {
            return this.keySerializer != null ? this.keySerializer.deserialize(value) : value;
        }
    
        private List<Object> deserializeMixedResults(List<Object> rawValues, RedisSerializer valueSerializer, RedisSerializer hashKeySerializer, RedisSerializer hashValueSerializer) {
            if (rawValues == null) {
                return null;
            } else {
                List<Object> values = new ArrayList();
                Iterator var6 = rawValues.iterator();
    
                while(true) {
                    while(var6.hasNext()) {
                        Object rawValue = var6.next();
                        if (rawValue instanceof byte[] && valueSerializer != null) {
                            values.add(valueSerializer.deserialize((byte[])((byte[])rawValue)));
                        } else if (rawValue instanceof List) {
                            values.add(this.deserializeMixedResults((List)rawValue, valueSerializer, hashKeySerializer, hashValueSerializer));
                        } else if (rawValue instanceof Set && !((Set)rawValue).isEmpty()) {
                            values.add(this.deserializeSet((Set)rawValue, valueSerializer));
                        } else if (rawValue instanceof Map && !((Map)rawValue).isEmpty() && ((Map)rawValue).values().iterator().next() instanceof byte[]) {
                            values.add(SerializationUtils.deserialize((Map)rawValue, hashKeySerializer, hashValueSerializer));
                        } else {
                            values.add(rawValue);
                        }
                    }
    
                    return values;
                }
            }
        }
    
        private Set<?> deserializeSet(Set rawSet, RedisSerializer valueSerializer) {
            if (rawSet.isEmpty()) {
                return rawSet;
            } else {
                Object setValue = rawSet.iterator().next();
                if (setValue instanceof byte[] && valueSerializer != null) {
                    return SerializationUtils.deserialize(rawSet, valueSerializer);
                } else {
                    return setValue instanceof Tuple ? this.convertTupleValues(rawSet, valueSerializer) : rawSet;
                }
            }
        }
    
        //拼装数组值
        private Set<TypedTuple<V>> convertTupleValues(Set<Tuple> rawValues, RedisSerializer valueSerializer) {
            Set<TypedTuple<V>> set = new LinkedHashSet(rawValues.size());
    
            Tuple rawValue;
            Object value;
            for(Iterator var4 = rawValues.iterator(); var4.hasNext(); set.add(new DefaultTypedTuple(value, rawValue.getScore()))) {
                rawValue = (Tuple)var4.next();
                value = rawValue.getValue();
                if (valueSerializer != null) {
                    value = valueSerializer.deserialize(rawValue.getValue());
                }
            }
    
            return set;
        }
    
        public List<Object> exec() {
            List<Object> results = this.execRaw();
            return this.getConnectionFactory().getConvertPipelineAndTxResults() ? this.deserializeMixedResults(results, this.valueSerializer, this.hashKeySerializer, this.hashValueSerializer) : results;
        }
    
        public List<Object> exec(RedisSerializer<?> valueSerializer) {
            return this.deserializeMixedResults(this.execRaw(), valueSerializer, valueSerializer, valueSerializer);
        }
    
        protected List<Object> execRaw() {
            return (List)this.execute(new RedisCallback<List<Object>>() {
                public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.exec();
                }
            });
        }
    
        //删除,根据键删除值
        public void delete(K key) {
            final byte[] rawKey = this.rawKey(key);
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) {
                    connection.del(new byte[][]{rawKey});
                    return null;
                }
            }, true);
        }
    
        //删除,根据键的集合,批量删除值
        public void delete(Collection<K> keys) {
            if (!CollectionUtils.isEmpty(keys)) {
                final byte[][] rawKeys = this.rawKeys(keys);
                this.execute(new RedisCallback<Object>() {
                    public Object doInRedis(RedisConnection connection) {
                        connection.del(rawKeys);
                        return null;
                    }
                }, true);
            }
        }
    
        //是否含有指定的键
        public Boolean hasKey(K key) {
            final byte[] rawKey = this.rawKey(key);
            return (Boolean)this.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    return connection.exists(rawKey);
                }
            }, true);
        }
    
        //缓存是否过期
        //expire 期满; 文件、协议等(因到期而)失效; 断气; 逝世;
        public Boolean expire(K key, final long timeout, final TimeUnit unit) {
            final byte[] rawKey = this.rawKey(key);
            final long rawTimeout = TimeoutUtils.toMillis(timeout, unit);
            return (Boolean)this.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    try {
                        return connection.pExpire(rawKey, rawTimeout);
                    } catch (Exception var3) {
                        return connection.expire(rawKey, TimeoutUtils.toSeconds(timeout, unit));
                    }
                }
            }, true);
        }
    
        public Boolean expireAt(K key, final Date date) {
            final byte[] rawKey = this.rawKey(key);
            return (Boolean)this.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    try {
                        return connection.pExpireAt(rawKey, date.getTime());
                    } catch (Exception var3) {
                        return connection.expireAt(rawKey, date.getTime() / 1000L);
                    }
                }
            }, true);
        }
    
        //订阅发布
        public void convertAndSend(String channel, Object message) {
            Assert.hasText(channel, "a non-empty channel is required");
            final byte[] rawChannel = this.rawString(channel);
            final byte[] rawMessage = this.rawValue(message);
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) {
                    connection.publish(rawChannel, rawMessage);
                    return null;
                }
            }, true);
        }
    
        public Long getExpire(K key) {
            final byte[] rawKey = this.rawKey(key);
            return (Long)this.execute(new RedisCallback<Long>() {
                public Long doInRedis(RedisConnection connection) {
                    return connection.ttl(rawKey);
                }
            }, true);
        }
    
        public Long getExpire(K key, final TimeUnit timeUnit) {
            final byte[] rawKey = this.rawKey(key);
            return (Long)this.execute(new RedisCallback<Long>() {
                public Long doInRedis(RedisConnection connection) {
                    try {
                        return connection.pTtl(rawKey, timeUnit);
                    } catch (Exception var3) {
                        return connection.ttl(rawKey, timeUnit);
                    }
                }
            }, true);
        }
    
        public Set<K> keys(K pattern) {
            final byte[] rawKey = this.rawKey(pattern);
            Set<byte[]> rawKeys = (Set)this.execute(new RedisCallback<Set<byte[]>>() {
                public Set<byte[]> doInRedis(RedisConnection connection) {
                    return connection.keys(rawKey);
                }
            }, true);
            return this.keySerializer != null ? SerializationUtils.deserialize(rawKeys, this.keySerializer) : rawKeys;
        }
    
        //持久化
        //persist:坚持; 存留; 固执; 继续存在;
        public Boolean persist(K key) {
            final byte[] rawKey = this.rawKey(key);
            return (Boolean)this.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    return connection.persist(rawKey);
                }
            }, true);
        }
    
        //move移动
        public Boolean move(K key, final int dbIndex) {
            final byte[] rawKey = this.rawKey(key);
            return (Boolean)this.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    return connection.move(rawKey, dbIndex);
                }
            }, true);
        }
    
        //获取随机key值
        public K randomKey() {
            byte[] rawKey = (byte[])this.execute(new RedisCallback<byte[]>() {
                public byte[] doInRedis(RedisConnection connection) {
                    return connection.randomKey();
                }
            }, true);
            return this.deserializeKey(rawKey);
        }
    
        //key值重命名
        public void rename(K oldKey, K newKey) {
            final byte[] rawOldKey = this.rawKey(oldKey);
            final byte[] rawNewKey = this.rawKey(newKey);
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) {
                    connection.rename(rawOldKey, rawNewKey);
                    return null;
                }
            }, true);
        }
    
        //如果没有就重命名
        //Absent 缺席的,不在场的; 缺少的,缺乏的; 不在意的,茫然的;
        public Boolean renameIfAbsent(K oldKey, K newKey) {
            final byte[] rawOldKey = this.rawKey(oldKey);
            final byte[] rawNewKey = this.rawKey(newKey);
            return (Boolean)this.execute(new RedisCallback<Boolean>() {
                public Boolean doInRedis(RedisConnection connection) {
                    return connection.renameNX(rawOldKey, rawNewKey);
                }
            }, true);
        }
    
        //DataType类型的 类型
        public DataType type(K key) {
            final byte[] rawKey = this.rawKey(key);
            return (DataType)this.execute(new RedisCallback<DataType>() {
                public DataType doInRedis(RedisConnection connection) {
                    return connection.type(rawKey);
                }
            }, true);
        }
    
        public byte[] dump(K key) {
            final byte[] rawKey = this.rawKey(key);
            return (byte[])this.execute(new RedisCallback<byte[]>() {
                public byte[] doInRedis(RedisConnection connection) {
                    return connection.dump(rawKey);
                }
            }, true);
        }
    
        //restore 修复; 归还; 交还; 使恢复;
        public void restore(K key, final byte[] value, long timeToLive, TimeUnit unit) {
            final byte[] rawKey = this.rawKey(key);
            final long rawTimeout = TimeoutUtils.toMillis(timeToLive, unit);
            this.execute(new RedisCallback<Object>() {
                public Boolean doInRedis(RedisConnection connection) {
                    connection.restore(rawKey, rawTimeout, value);
                    return null;
                }
            }, true);
        }
    
        //multi 前缀
        public void multi() {
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.multi();
                    return null;
                }
            }, true);
        }
    
        //discard 丢弃,抛弃; 解雇; 出牌;
        public void discard() {
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.discard();
                    return null;
                }
            }, true);
        }
    
        //watch 注视,注意; 看守,监视; 守候(机会等); 密切注意
        public void watch(K key) {
            final byte[] rawKey = this.rawKey(key);
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) {
                    connection.watch(new byte[][]{rawKey});
                    return null;
                }
            }, true);
        }
    
        public void watch(Collection<K> keys) {
            final byte[][] rawKeys = this.rawKeys(keys);
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) {
                    connection.watch(rawKeys);
                    return null;
                }
            }, true);
        }
    
        public void unwatch() {
            this.execute(new RedisCallback<Object>() {
                public Object doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.unwatch();
                    return null;
                }
            }, true);
        }
    
        //sort 排序
        public List<V> sort(SortQuery<K> query) {
            return this.sort(query, this.valueSerializer);
        }
    
        public <T> List<T> sort(SortQuery<K> query, RedisSerializer<T> resultSerializer) {
            final byte[] rawKey = this.rawKey(query.getKey());
            final SortParameters params = QueryUtils.convertQuery(query, this.stringSerializer);
            List<byte[]> vals = (List)this.execute(new RedisCallback<List<byte[]>>() {
                public List<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.sort(rawKey, params);
                }
            }, true);
            return SerializationUtils.deserialize(vals, resultSerializer);
        }
    
        public <T> List<T> sort(SortQuery<K> query, BulkMapper<T, V> bulkMapper) {
            return this.sort(query, bulkMapper, this.valueSerializer);
        }
    
        public <T, S> List<T> sort(SortQuery<K> query, BulkMapper<T, S> bulkMapper, RedisSerializer<S> resultSerializer) {
            List<S> values = this.sort(query, resultSerializer);
            if (values != null && !values.isEmpty()) {
                int bulkSize = query.getGetPattern().size();
                List<T> result = new ArrayList(values.size() / bulkSize + 1);
                List<S> bulk = new ArrayList(bulkSize);
                Iterator var8 = values.iterator();
    
                while(var8.hasNext()) {
                    S s = var8.next();
                    bulk.add(s);
                    if (bulk.size() == bulkSize) {
                        result.add(bulkMapper.mapBulk(Collections.unmodifiableList(bulk)));
                        bulk = new ArrayList(bulkSize);
                    }
                }
    
                return result;
            } else {
                return Collections.emptyList();
            }
        }
    
        public Long sort(SortQuery<K> query, K storeKey) {
            final byte[] rawStoreKey = this.rawKey(storeKey);
            final byte[] rawKey = this.rawKey(query.getKey());
            final SortParameters params = QueryUtils.convertQuery(query, this.stringSerializer);
            return (Long)this.execute(new RedisCallback<Long>() {
                public Long doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.sort(rawKey, params, rawStoreKey);
                }
            }, true);
        }
    
        //BoundValueOperations暂时不知道什么意思,可能是操作边界值
        //bound n界限,限制; 跃起; (球等的) 反跳 ,v缚; 给…划界,限制; 使弹回,使跳跃;
        public BoundValueOperations<K, V> boundValueOps(K key) {
            return new DefaultBoundValueOperations(key, this);
        }
    
        //操作值,描述具有简单值的条目
        public ValueOperations<K, V> opsForValue() {
            if (this.valueOps == null) {
                this.valueOps = new DefaultValueOperations(this);
            }
    
            return this.valueOps;
        }
    
        //操作集合,操作具有list值的条目
        public ListOperations<K, V> opsForList() {
            if (this.listOps == null) {
                this.listOps = new DefaultListOperations(this);
            }
    
            return this.listOps;
        }
    
        //以绑定指定key的方式,操作具有list的条目
        public BoundListOperations<K, V> boundListOps(K key) {
            return new DefaultBoundListOperations(key, this);
        }
    
        //以绑定指定key的方式,操作具有set的条目
        public BoundSetOperations<K, V> boundSetOps(K key) {
            return new DefaultBoundSetOperations(key, this);
        }
    
        //操作具有set值的条目
        public SetOperations<K, V> opsForSet() {
            if (this.setOps == null) {
                this.setOps = new DefaultSetOperations(this);
            }
    
            return this.setOps;
        }
    
        //以绑定指定key的方式,操作具有ZSet(排序的set)的条目
        public BoundZSetOperations<K, V> boundZSetOps(K key) {
            return new DefaultBoundZSetOperations(key, this);
        }
    
        //操作具有ZSet值(排序的set)的条目
        public ZSetOperations<K, V> opsForZSet() {
            if (this.zSetOps == null) {
                this.zSetOps = new DefaultZSetOperations(this);
            }
    
            return this.zSetOps;
        }
    
        //Geospatial 键操作
        public GeoOperations<K, V> opsForGeo() {
            if (this.geoOps == null) {
                this.geoOps = new DefaultGeoOperations(this);
            }
    
            return this.geoOps;
        }
    
        //Redis Geospatial 键绑定操作
        public BoundGeoOperations<K, V> boundGeoOps(K key) {
            return new DefaultBoundGeoOperations(key, this);
        }
    
        //操作Redis HyperLogLog类型数据,比如:pfadd,pfcount,...
        public HyperLogLogOperations<K, V> opsForHyperLogLog() {
            if (this.hllOps == null) {
                this.hllOps = new DefaultHyperLogLogOperations(this);
            }
    
            return this.hllOps;
        }
    
        //Redis Hash键绑定操作
        public <HK, HV> BoundHashOperations<K, HK, HV> boundHashOps(K key) {
            return new DefaultBoundHashOperations(key, this);
        }
    
        //操作Redis Hash类型数据
        public <HK, HV> HashOperations<K, HK, HV> opsForHash() {
            return new DefaultHashOperations(this);
        }
    
        //Cluster 群操作
        public ClusterOperations<K, V> opsForCluster() {
            return new DefaultClusterOperations(this);
        }
    
        public void killClient(final String host, final int port) {
            this.execute(new RedisCallback<Void>() {
                public Void doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.killClient(host, port);
                    return null;
                }
            });
        }
    
        //获取redis客户端的集合
        public List<RedisClientInfo> getClientList() {
            return (List)this.execute(new RedisCallback<List<RedisClientInfo>>() {
                public List<RedisClientInfo> doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.getClientList();
                }
            });
        }
    
        //SLAVEOF 命令用于在 Redis 运行时动态地修改复制(replication)功能的行为
        public void slaveOf(final String host, final int port) {
            this.execute(new RedisCallback<Void>() {
                public Void doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.slaveOf(host, port);
                    return null;
                }
            });
        }
    
        public void slaveOfNoOne() {
            this.execute(new RedisCallback<Void>() {
                public Void doInRedis(RedisConnection connection) throws DataAccessException {
                    connection.slaveOfNoOne();
                    return null;
                }
            });
        }
    
        public void setEnableTransactionSupport(boolean enableTransactionSupport) {
            this.enableTransactionSupport = enableTransactionSupport;
        }
    
        public void setBeanClassLoader(ClassLoader classLoader) {
            this.classLoader = classLoader;
        }
    }
    

    这个类基本上就是所有的RedisTemplate.方法就可以用了哟。
    例如:

    /**保存成功后同步到缓存中**/
                    redisTemplate.opsForList().rightPush(CachePrefix.CERT_BUNDLE_LIST + "_" + iosBundle.getCertId(), iosBundle.getId());
    展开全文
  • 把"回归正交试验分析法"引入到数值计算中,用较少的计算次数,计算出不同长度内衬对坡口对焊接头冻结承载力的影响。计算结果表明:冻结直径越大,增加内衬长度对提高冻结承载力的影响越显著;对直径小于130mm的...
  • 很多人都建议jquery使用cdn加速的方式引入。当然,我不反对这么做。但是以我自己做项目的便利性,我还是习惯把jq放在本地使用。原因有以下几点: 项目的可靠性。不会受外在的情况的影响。 在断网的情况下依旧可以...
  • maven引入私服jar

    千次阅读 2016-08-24 18:22:57
    1通过网页上传 这种方法只是上传了jar包。...通过maven引入jar时,会自动加载jar的依赖 2通过maven的方式depoly 在maven的conf/setting.xml 配置nexus私服的管理账号 在servers标签下添加server
  • 使用npm 引入WeUi组件

    千次阅读 2020-05-27 22:58:13
    文章目录一、引言1、WeUI组件:2、官方说明WeUI引入方式有两种:3、了解npm是神马:二、正文1、安装npm。到官网[https://nodejs.org/en/download/](https://nodejs.org/en/download/)下载安装包2、在项目详细中勾选...
  • Android Studio引入依赖的方法

    千次阅读 2017-04-21 19:51:09
    引入开源的模块或者jar包 方法一 切换到project视图,将下载好的jar包复制粘贴到project模式下的app文件夹下的libs目录中 右键点击粘贴的jar包在菜单中选择Add As Library,即可使用引入的jar包了 完成,此方法引入...
  • springboot maven引入本地jar包

    千次阅读 2018-09-05 17:57:33
    问题描述 最近尝试引入阿里云的jar包...了很多网上的帖子,很多都说用plugin 中resource来弄,对我的项目一点鸟用也没有。最后还是在stackoverflow上找到了答案,所以做了以下总结。 解决 如何引入本地jar包 ...
  • 1.引入: 先来个小案例:使用scrapy爬取百度图片。( 目标百度图片URL: https://image.baidu.com/search/index?tn=baiduimage&ipn=r&ct=201326592&cl=2&lm=-1&st=-1&sf=1&fmq=&...
  • 横向PNP、纵向PNP的结构与特点 由于模拟集成电路中要应用NPN-PNP互补设计以及某些偏置电路极性的要求,需要引入PNP结构的晶体。图A 示出集成电路中的两种PNP型。其中,横向PNP广泛应用于有源负载、电平...
  • 蝶形引入皮线光缆FTTH特点介绍

    千次阅读 2020-08-26 09:15:10
    蝶形引入光缆又称皮线光缆、FTTH光缆,因截面呈蝴蝶形而得名。蝶形引入光缆结构非常简单,但不失它作为室内光缆所应有的特点。蝶形引入光缆横截面呈蝴蝶形,光纤位于蝴蝶形的几何中心,在光纤两侧对称设置两根KFRP...
  • 导光技术可将天然光引入大型公共建筑及地下空间,为人们提供舒适、洁净,有利于健康的光环境。导光有利于节约能源、减少污染,具有极大的应用前景。通过对导光设备技术的分析和奥运体育馆、地下车库的导光技术...
  • 文章介绍了钢管端缺陷检测盲区的形成,借助Ansys有限元分析软件强大的电磁场分析能力和实体建模功能对钢管端磁场分布进行分析,确定了端缺陷检测中引入引体消除检测盲区的必要性,并建立相应的磁场模型以研究...
  • Cache层次结构的引入

    千次阅读 2015-05-10 10:29:25
    我经常尝试一些方法,试图去解决在存储器...1975年,Moor将其定律修正为“晶体的数目每18月增加一倍,性能也将提高一倍”。这个定律在维持了相当长一段时间的正确性之后逐步失效。首先体现在性能提高一倍上,使用过多
  • 电子产品生产中不可或缺的两个核心“人物”,那便是MOS与三极管,它们两者都在电路中发挥着重要的效果,尤其是MOS,深受电子工程师的喜爱,因为MOS相比于三极管,开关速度快,导通电压低,电压驱动简略,所以...
  • 将testng引入到Eclipse步骤: (上图内容来自http://testng.org/doc/download.html) 具体来说,在网址:http://beust.com/eclipse下载对应的文件,    可以下载最下边的zip文件,然后自行解压,解压后文件...
  • 在PSpice软件中用一个表格宏模型和电压控制模块来反映触发的触发特性和正向导通过程,并且把影响触发自击穿特性的非电物理因素诸如管内气压、主电极距离和管内气体电离参数转化为电压后引入模型。经过相关的测试...
  • Vue采用CDN方式引入基础第三方库及Vuetify框架

    千次阅读 热门讨论 2020-05-22 21:21:44
    Vue服务引入大量第三方库时,如果采用npm install的方式引入,打包时代码体积过大,对于小水管服务器不友好,这时候采用CDN进行库的动态引入会极大地减轻服务器的带宽压力,提高首屏渲染的效率 public/index.html &...
  • 以第一个供暖季为例,分析内管导热系数和循环水流量对换热性能的影响,并引入换热器效能对热短路现象进行评估,研究结果显示:内管导热系数越大,热短路现象越显著;热短路使内外中循环水温差降低,管内出现热堆积...
  • Vue项目引入移动端组件库--Mand Mobile

    千次阅读 2019-11-04 22:12:54
    Vue项目引入移动端组件库--Mand MobileMand Mobile安装全量引入按需加载(推荐) Mand Mobile Mand Mobile是面向金融场景设计的移动端组件库,基于Vue.js实现。目前已实际应用于滴滴四大金融业务板块的10余款产品中。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 146,235
精华内容 58,494
关键字:

引入管怎么看