为了不让代码看起来像一坨*,我在工作中反复用了这个

全链路追踪必备组件之 TransmittableThreadLocal 详解 ThreadLocal 线程传递 & TransmittableThreadLocal 源码解析 文章目录ThreadLocal 线程传递 & TransmittableThreadLocal 源码解析InheritableThreadLocal缺点RunnableWrapper/ CallableWrapperDelegaingExecutorTransmittableThrea... 阅读详情

点击上方“芋道源码”,选择“设为星标”

管她前浪,还是后浪?

能浪的浪,才是好浪!

每天 8:55 更新文章,每天掉亿点点头发...

源码精品专栏

 

来源:cnblogs.com/chopper-poet/p/12626768.html

  • 责任链设计模式

  • 策略设计模式

  • 模板设计模式

  • 观察者设计模式

  • 装饰器设计模式

  • 外观设计模式


大多数时候我都是写一些业务代码,可能一堆CRUD就能解决问题,但是这样的工作对技术人的提升并不多,如何让自己从业务中解脱出来找到写代码的乐趣呢,我做过一些尝试,使用设计模式改善自己的业务代码就是其中的一种。

责任链设计模式

责任链设计模式定义

请求在一个链条上处理,链条上的受理者处理完毕之后决定是继续往后传递还是中断当前处理流程。

适用场景

适用于多节点的流程处理,每个节点完成各自负责的部分,节点之间不知道彼此的存在,比如OA的审批流,java web开发中的Filter机制。举一个生活中的例子,笔者之前租房的时候遇到了所谓的黑中介,租的时候感觉自己是上帝,但是坏了东西找他修的时候就像个孙子一样,中介让我找门店客服,门店客服又让我找房东,房东又让我找她家老公,最终好说歹说才把这事了了(租房一定要找正规中介)。

实践经验

笔者目前所做的业务是校园团餐的聚合支付,业务流程很简单,1.学生打开手机付款码支付,2.食堂大妈使用机具扫付款码收款。大学食堂有个背景是这样的,食堂有补贴,菜品比较便宜,所以学校是不愿意让社会人士去学校食堂消费的,鉴于此,我们在支付之前加了一套是否允许支付的检验逻辑,大体如下:1.某档口只允许某类用户用户消费,比如教师档口只允许教师消费,学生档口不允许校外用户消费;2.某个档口一天只允许某类用户消费几次,比如教师食堂一天只允许学生消费一次;3.是否允许非清真学生消费,比如某些清真餐厅,是不允许非清真学生消费的;针对这几类情况我建立了三类过滤器,分别是:SpecificCardUserConsumeLimitFilter:按用户类型判断是否允许消费 DayConsumeTimesConsumeLimitFilter:按日消费次数判断是否允许消费 MuslimConsumeLimitFilter:非清真用户是否允许消费 判断逻辑是先通过SpecificCardUserConsumeLimitFilter判断当前用户是否可以在此档口消费,如果允许继续由DayConsumeTimesConsumeLimitFilter判断当天消费次数是否已用完,如果未用完继续由MuslimConsumeLimitFilter判断当前用户是否满足清真餐厅的就餐条件,前面三条判断,只要有一个不满足就提前返回。部分代码如下:

public boolean canConsume(String uid,String shopId,String supplierId){
    //获取用户信息,用户信息包含类型(student:学生,teacher:老师,unknown:未知用户)、名族(han:汉族,mg:蒙古族)
    UserInfo userInfo = getUserInfo(uid);
    //获取消费限制信息,限制信息包含是否允许非清真消费、每种类型的用户是否允许消费以及允许消费的次数
   ConsumeConfigInfo consumeConfigInfo = getConsumeConfigInfo(shopId,supplierId)


    // 构造消费限制过滤器链条
    ConsumeLimitFilterChain filterChain = new ConsumeLimitFilterChain();
    filterChain.addFilter(new SpecificCardUserConsumeLimitFilter());
    filterChain.addFilter(new DayConsumeTimesConsumeLimitFilter());
    filterChain.addFilter(new MuslimConsumeLimitFilter());
    boolean checkResult = filterChain.doFilter(filterChain, schoolMemberInfo, consumeConfigInfo);

    //filterChain.doFilter方法
   public boolean doFilter(ConsumeLimitFilterChain filterChain,UserInfo userInfo,
    ConsumeConfigInfo consumeConfigInfo ){
  //迭代调用过滤器
  if(index<filters.size()){
      return filters.get(index++).doFilter(filterChain, userInfo, consumeConfigInfo);
  }
    }

    //SpecificCardUserConsumeLimitFilter.doFilter方法
     public boolean doFilter(ConsumeLimitFilterChain filterChain,UserInfo userInfo,
    ConsumeConfigInfo consumeConfigInfo ){
                //获取某一类型的消费限制,比如student允许消费,unknown不允许消费
  CardConsumeConfig cardConsumeConfig = findSuitCardConfig(userInfo, consumeConfigInfo);

  // 判断当前卡用户是否允许消费
  if (consumeCardConfig != null) {
   if ((!CAN_PAY.equals(cardConsumeConfig .getEnabledPay()))) {
       return false;
   }
  }

                //其余情况,继续往后传递
            return filterChain.doFilter(filterChain, memberInfo, consumeConfig);
        }

    //DayConsumeTimesConsumeLimitFilter.doFilter方法
     public boolean doFilter(ConsumeLimitFilterChain filterChain,UserInfo userInfo,
    ConsumeConfigInfo consumeConfigInfo ){
                //获取某一类型的消费限制,比如student可以消费2次
  CardConsumeConfig cardConsumeConfig = findSuitCardConfig(userInfo, consumeConfigInfo);

                //获取当前用户今天的消费次数
                int consumeCnt = getConsumeCnt(userInfo)
  if(consumeCnt >= cardConsumeConfig.getDayConsumeTimesLimit()){
                    return false;
                }

                //其余情况,继续往后传递
                return filterChain.doFilter(filterChain, memberInfo, consumeConfig);
        }

总结

将每种限制条件的判断逻辑封装到了具体的Filter中,如果某种限制条件的逻辑有修改不会影响其他条件,如果需要新加限制条件只需要重新构造一个Filter织入到FilterChain上即可。

策略设计模式

策略设计模式定义

定义一系列的算法,把每一个算法封装起来, 并且使它们可相互替换

适用场景

主要是为了消除大量的if else代码,将每种判断背后的算法逻辑提取到具体的策略对象中,当算法逻辑修改时对使用者无感知,只需要修改策略对象内部逻辑即可。这类策略对象一般都实现了某个共同的接口,可以达到互换的目的。

实践经验

笔者之前有个需求是用户扫码支付以后向档口的收银设备推送一条支付消息,收银设备收到消息以后会进行语音播报,逻辑很简单,就是调用推送平台推送一条消息给设备即可,但是由于历史原因,某些设备对接的推送平台是不一样的,A类设备优先使用信鸽推送,如果失败了需要降级到长轮询机制,B类设备直接使用自研的推送平台即可,还有个现状是A类和B类的消息格式是不一样的(不同的团队开发,后期被整合到一起),鉴于此,我抽象出PushStrategy接口,其具体的实现有IotPushStrategy和XingePushStrategy,分别对应自研推送平台的推送策略和信鸽平台的推送策略,使用者时针对不同的设备类型使用不同的推送策略即可。部分代码如下:

/**
 * 推送策略
 * /
public interface PushStrategy {
 /**
         @param deviceVO设备对象,包扣设备sn,信鸽pushid
         @param content,推送内容,一般为json
        */
 public CallResult push(AppDeviceVO deviceVO, Object content);
}

IotPushStrategy implements PushStrategy{
        /**
         @param deviceVO设备对象,包扣设备sn,信鸽pushid
         @param content,推送内容,一般为json
        */
 public CallResult push(AppDeviceVO deviceVO, Object content){
            //创建自研推送平台需要的推送报文
            Message message = createPushMsg(deviceVO,content);

            //调用推送平台推送接口
            IotMessageService.pushMsg(message);
        }
}

XingePushStrategy implements PushStrategy{
        /**
         @param deviceVO设备对象,包扣设备sn,信鸽pushid
         @param content,推送内容,一般为json
        */
 public CallResult push(AppDeviceVO deviceVO, Object content){
            //创建信鸽平台需要的推送报文
            JSONObject jsonObject = createPushMsg(content);

            //调用推送平台推送接口
            if(!XinggePush.pushMsg(message)){
                //降级到长轮询
                ...
            }
        }
}

/**
消息推送Service
*/
MessagePushService{
    pushMsg(AppDeviceVO deviceVO, Object content){
        if(A设备){
            XingePushStrategy.push(deviceVO,content);
        } else if(B设备){
            IotPushStrategy.push(deviceVO,content);
        }
    }
}

总结

将每种通道的推送逻辑封装到了具体的策略中,某种策略的变更不会影响其他策略,由于实现了共同接口,所以策略可以互相替换,对使用者友好,比如java ThreadPoolExecutor中的任务拒绝策略,当线程池已经饱和的时候会执行拒绝策略,具体的拒绝逻辑被封装到了RejectedExecutionHandler的rejectedExecution中。

模板设计模式

模板设计模式定义

模板的价值就在于骨架的定义,骨架内部将问题处理的流程已经定义好,通用的处理逻辑一般由父类实现,个性化的处理逻辑由子类实现。比如炒土豆丝和炒麻婆豆腐,大体逻辑都是1.切菜,2.放油,3.炒菜,4.出锅,1,2,4都差不多,但是第3步是不一样的,炒土豆丝得拿铲子翻炒,但是炒麻婆豆腐得拿勺子轻推,否则豆腐会烂(疫情宅在家,学了不少菜)。

使用场景

不同场景的处理流程,部分逻辑是通用的,可以放到父类中作为通用实现,部分逻辑是个性化的,需要子类去个性实现。

实践经验

还是接着之前语音播报的例子来说,后期我们新加了两个需求:1.消息推送需要增加trace 2.有些通道推送失败需要重试 所以现在的流程变成了这样:1.trace开始 2.通道开始推送 3.是否允许重试,如果允许执行重试逻辑 4.trace结束 其中1和4是通用的,2和3是个性化的,鉴于此我在具体的推送策略之前增加了一层父类的策略,将通用逻辑放到了父类中,修改后的代码如下:

abstract class AbstractPushStrategy implements PushStrategy{
    @Override
    public CallResult push(AppDeviceVO deviceVO, Object content) {
        //1.构造span
        Span span = buildSpan();
        //2.具体通道推送逻辑由子类实现
        CallResult callResult = doPush(deviceVO, content);

        //3.是否允许重试逻辑由子类实现,如果允许执行重试逻辑
        if(!callResult.isSuccess() && canRetry()){
            doPush(deviceVO, content);
        }

        //4.trace结束
        span.finish()
    }

    //具体推送逻辑由子类实现
    protected abstract CallResult doPush(AppDeviceVO deviceDO, Object content) ;

    //是否允许重试由子类实现,有些通道之前没有做消息排重,所有不能重试
    protected abstract boolean canRetry(CallResult callResult);

}

XingePushStrategy extends AbstractPushStrategy{
    @Override
    protected CallResult doPush(AppDeviceVO deviceDO, Object content) {
        //执行推送逻辑
    }

    @Override
    protected boolean canRetry(CallResult callResult){
        return false
    }
}

总结

通过模板定义了流程,将通用逻辑放在父类实现,减少了重复代码,个性化逻辑由子类自己实现,子类间修改代码互不干扰也不会破坏流程。

观察者设计模式

观察者设计模式定义

顾名思义,此模式需要有观察者(Observer)和被观察者(Observable)两类角色,当Observable状态变化时会通知Observer,Observer一般会实现一类通用的接口,比如java.util.Observer,Observable需要通知Observer时,逐个调用Observer的update方法即可,Observer的处理成功与否不应该影响Observable的流程。

使用场景

一个对象(Observable)状态改变需要通知其他对象,Observer的存在不影响Observable的处理结果,Observer的增删对Observable无感知,比如kafka的消息订阅,producer发送一条消息到topic,至于是1个还是10个consumer订阅这个topic,producer是不需要关注的。

实践经验

在责任链设计模式那块我通过三个Filter解决了消费限制检验的问题,其中有一个Filter是用来检验消费次数的,我这里只是读取用户的消费次数,那么消费次数的累加是怎么完成的呢?其实累加这块就用到了观察者模式,具体来讲是这样,当交易系统收到支付成功回调时会通过Spring的事件机制发布“支付成功事件”,这样负责累加消费次数和负责语音播报的订阅者就会收到“支付成功事件”,进而做各自的业务逻辑,画个简单的图描述一下:代码结构大体如下:

/**
支付回调处理者
*/
PayCallBackController implements ApplicationContextAware {
     private ApplicationContext applicationContext;

    //如果想获取applicationContext需要实现ApplicationContextAware接口,Spring容器会回调setApplicationContext方法将applicationContext注入进来
    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException {
        this.applicationContext = applicationContext;
    }
     @RequestMapping(value = "/pay/callback.do")
     public View callback(HttpServletRequest request){
        if(paySuccess(request){
            //构造支付成功事件
            PaySuccessEvent event = buildPaySuccessEvent(...);
            //通过applicationContext发布事件,从而达到通知观察者的目的
            this.applicationContext.publishEvent(event);
        }
    }
}
/**
 * 语音播报处理者
 *
 */
public class VoiceBroadcastHandler implements ApplicationListener<PaySuccessEvent>{
    @Override
    public void onApplicationEvent(PaySuccessEvent event) {
        //语音播报逻辑
    }
}

//其他处理者的逻辑类似

总结

观察者模式将被观察者和观察者之间做了解耦,观察者存在与否不会影响被观察者的现有逻辑。

装饰器设计模式

装饰器设计模式定义

装饰器用来包装原有的类,在对使用者透明的情况下做功能的增强,比如java中的BufferedInputStream可以对其包装的InputStream做增强,从而提供缓冲功能。

使用场景

希望对原有类的功能做增强,但又不希望增加过多子类时,可以使用装饰器模式来达到同样的效果。

实践经验

笔者之前在推动整个公司接入trace体系,因此也提供了一些工具来解决trace的自动织入和上下文的自动传递,如果有兴趣的可以看我另一篇博客jaeger使用初探,为了支持线程间的上下文传递,我增加了TraceRunnableWrapper这个装饰类,从而起到将父线程的上下文透传到子线程中,对使用者完全透明,代码如下:

/**
可以自动携带trace上下文的Runnable装饰器
*/
public class TraceRunnableWrapper implements Runnable{
    //被包装的目标对象
    private Runnable task;
    private Span parentSpan = null;

    public TraceRunnableWrapper(Runnable task) {
        //1.获取当前线程的上下文(因为new的时候还没有发生线程切换,所以需要在这里将上下文获取)
        //对这块代码感兴趣的可以查看opentracing API
        io.opentracing.Scope currentScope = GlobalTracer.get().scopeManager().active();
        //2.保存父上下文
        parentSpan = currentScope.span();
        this.task = task;
    }

    @Override
    public void run() {
        //run的时候将父线程的上下文绑定到当前线程
        io.opentracing.Scope scope = GlobalTracer.get().scopeManager().activate(parentSpan,false);
        task.run();
    }
}

//使用者
new Thread(new Runnable(){run(...)}).start()替换为new TraceRunnableWrapper(new Runnable(){run(...)}).start()

总结

使用装饰器模式做了功能的增强,对使用者来说只需要做简单的组合就能继续使用原功能。

外观设计模式

外观设计模式定义

何为外观,就是对外提供一个统一的入口,一是可以影藏系统内部的细节,二是可以降低使用者的复杂度,比如SpringMvc中的DispaterServlet,所有的Controller都是通过DispaterServlet统一暴露。

使用场景

降低使用者的复杂度,简化客户端的接入成本。

实践经验

笔者所在的公司对外提供了一些开放能力给第三方ISV,比如设备管控、统一支付、对账单下载等能力,由于分属于不同的团队,所以对外提供的接口形式各异,初期还好,接口不多,ISV也能接受,但是后期接口多了ISV就开始抱怨接入成本太高,为了解决这一问题,我们在开放接口前面加了一层前端控制器GatewayController,其实就是我们后来开放平台的雏形,GatewayController对外统一暴露一个接口gateway.do,将对外接口的请求参数和响应参数统一在GatewayController做收敛,GatewayController往后端服务路由时也采用统一接口,改造前后对比如下图:

大概代码如下:

使用者:
HttpClient.doPost("/gateway.do","{'method':'trade.create','sign':'wxxaaa','timestamp':'15311111111'},'bizContent':'业务参数'")

GatewayController:
@RequestMapping("/gateway.do")
JSON gateway(HttpServletRequest req){
   //1.组装开放请求
   OpenRequest openRequest = buildOpenRequest(req);

   OpenResponse openResponse = null;
   //2.请求路由
   if("trade.create".equals(openRequest.getMethod()){
       //proxy to trade service by dubbo
       openResponse = TradeFacade.execute(genericParam);
   } else if("iot.message.push".equals(openRequest.getMethod()){
       //proxy to iot service by httpclient
        openResponse = HttpClient.doPost('http://iot.service/generic/execute'genericParam);
   }

   if(openResponse.isSuccess()){
        return {"code":"10000","bizContent":openResponse.getResult()};
   }else{
        return {"code":"20000","bizCode":openResponse.getCode()};
   }


}

总结:采用外观模式屏蔽了系统内部的一些细节,降低了使用者的接入成本,就拿GatewayController来说,ISV的鉴权,接口的验签等重复工作统一由它实现,ISV对接不同的接口只需要关心一套接口协议接口,由GatewayController这一层做了收敛。



欢迎加入我的知识星球,一起探讨架构,交流源码。加入方式,长按下方二维码噢:

已在知识星球更新源码解析如下:

最近更新《芋道 SpringBoot 2.X 入门》系列,已经 20 余篇,覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例,以及超 4W 行代码的电商微服务项目。

获取方式:点“在看”,关注公众号并回复 666 领取,更多内容陆续奉上。

兄弟,艿一口,点个赞!????

windows重装系统反复重启 没有SATA Operation,就找VMD,VMD部分会处于隐藏状态,需要在 advanced模式下,ctrl+s唤出。 阅读详情

相关推荐

ESP32-WROOM编程出错造成反复重启故障恢复方法

由于编程烧写随机出错(可能是编程下载过程中USB转串口线接触不良造成的,记得检查USB接口,换根靠谱的USB线),造成ESP32反复重启,监控串口输出信息可以发现循环出错信息。经过几天查找解决办法,终于搞定了!

u011143455的博客 1万+

skywalking09 - 异步线程路线续接(中)

匿名内部类,lambda的异步线程的链路续接

过了这个村没这个老王的博客 2083

音乐记谱中的省略记号:震音、音型反复与小节反复详解

在音乐记谱领域,符号系统是记录和传达音乐信息的基础。其核心原理在于通过标准化的图形符号,高效表示音高、时值、力度等音乐参数,以实现跨时空的准确传递。掌握记谱法对于演奏、创作和分析具有重要技术价值,它能提升视奏效率,并帮助理解音乐结构。在实际应用场景中,尤其在处理重复性段落时,直接书写所有音符会导致谱面臃肿,影响可读性。为此,音乐记谱法发展出了多种省略记号,作为高效的“速记”工具。本文聚焦于其中三种实用记号:震音用于表示单个音或两个音之间的快速交替重复,音型反复记号用于复制小节内的固定节奏音型,而小节反复记号

weixin_34290631的博客 450

ThreadLocal父子线程值传递问题

父子线程值传递在项目中使用的场景还是非常多的,比如APM系统都有类似的需求;分布式系统中做链路追踪时,就会遇到线程A创建一个线程B时,无法追踪到线程B的执行过程; 这里列举一下常见的解决思路: 1. InheritableThreadLocal ...

shixiaoling123的博客 1499

7.3 双亲委派机制设计思想

双亲委派机制设计思想

杨充 1420

从0到1:提示工程架构师搭建Agentic AI系统的全流程实战手册

Agentic AI(自主智能体)是具备自主决策能力的大模型应用感知(Perceive):获取外部环境信息(比如代码仓库、用户输入、数据库数据);记忆(Memory):存储和检索历史信息(比如过去的审计记录、用户偏好);规划(Plan):将复杂任务拆解为可执行的步骤(比如“代码审计”拆成3步);行动(Act):调用工具或API完成具体操作(比如调用Git克隆仓库、调用Safety查漏洞);反馈(Feedback):根据结果调整策略(比如用户说“报告不够详细”,下次增加逻辑漏洞的分析深度)。

AI Agent Harness Engineering 1043

通过 Java 线程堆栈进行性能瓶颈分析

改善性能意味着用更少的资源做更多的事情。为了利用并发来提高系统性能,我们需要更有效的利用现有的处理器资源,这意味着我们期望使CPU尽可能出于忙碌状态(当然,并不是让CPU周期出来应付无用计算,而是让CPU做有用的事情而忙)。如果程序受限于当前的CPU计算能力,那么我们通过增加更多的处理器或者通过集群就能提高总的性能总的来说,性能提高,需要且仅需要解决当前的受限资源,当前受限资源可能是:CPU:如果...

javaxuexi123的博客 969

【DAY11】超参数调整专题1

核心优势: 它不是随机选择下一个点,而是根据先前评估的结果建立一个概率模型(通常是高斯过程),预测哪些参数组合可能产生更好的结果,并据此选择下一个评估点。这使得它在寻找最优解方面通常比随机搜索更高效(用更少的迭代次数达到相似或更好的性能),特别是当模型训练(单次评估)非常耗时的时候。实际上,有着非常多的方式可以实现贝叶斯优化,上面的代码比较简洁美观,贝叶斯优化和网格搜索的代码书写风格高度一致。- 需要定义参数的搜索空间,与随机搜索类似,当搜索空间非常大时,它通常比网格搜索和随机搜索更有效。

daomingwu1的博客 750

为了不让代码看起来像一坨* 我在工作中反复用了这个

大多数时候我都是写一些业务代码,可能一堆CRUD就能解决问题,但是这样的工作对技术人的提升并不多,如何让自己从业务中解脱出来找到写代码的乐趣呢,我做过一些尝试,使用设计模式改善自己的业务代码就是其中的一种。 责任链设计模式 定义 请求在一个链条上处理,链条上的受理者处理完毕之后决定是继续往后传递还是中断当前处理流程。 适用场景 适用于多节点的流程处理,每个节点完成各自负责的部分,节点之间不知道彼此的存在,比如OA的审批流,java web开发中的Filter机制。举一个生活中的例子,笔者之前租房的

代码界的扛把子 185

Ubuntu上安装Claude Code CLI:从环境配置到排错全攻略

在Linux开发环境中,命令行工具的安装与配置是开发者绕不开的基础技能。无论是AI编程助手还是其他CLI工具,其运行都依赖于正确的运行时环境和包管理机制。以Node.js生态为例,版本管理器nvm解决了多版本切换的痛点,npm则负责全局包的安装与依赖解析。理解PATH环境变量的执行逻辑、全局bin目录的作用以及权限控制,是排查“命令找不到”或“EACCES”错误的关键。这些基础知识应用广泛,从本地开发到服务器部署都至关重要。本文以Ubuntu系统上安装Anthropic的Claude Code CLI为例,

weixin_28842367的博客 273

2023-11-20 MySQL ARM64 银河麒麟

背景 MySQL是常用数据库,Windows安装比较容易,笔者也有记录。现在国产化系统银河麒麟中安装,不同的是软件安装包不容易下载。一是安装的方式,再一个是MySQL本身的版本,网上很多文档说明其实都是对的,但是为什么那么多都不一样呢?就是MySQL本身的版本差异比较大,这些差异笔者也不是很清楚,但是不要用8和5.7的差异非常大,8即使安装的很顺利,在使用过程也会很多坑,导致我宁愿卸载8,也要重新...

jxmh1991@163.com 814

码农的强迫症|为了不让代码看起来像一坨* 我在工作中反复用了这个

大多数时候我都是写一些业务代码,可能一堆CRUD就能解决问题,但是这样的工作对技术人的提升并不多,如何让自己从业务中解脱出来找到写代码的乐趣呢,我做过一些尝试,使用设计模式改善自己的业务代码就是其中的一种。 责任链设计模式 定义 请求在一个链条上处理,链条上的受理者处理完毕之后决定是继续往后传递还是中断当前处理流程。 适用场景 适用于多节点的流程处理,每个节点完成各自负责的部分,节点之间不知道彼此的存在,比如OA的审批流,java web开发中的Filter机制。举一个生活中的例子,笔者之前租房的

xiaomanong123的博客 244

Android应用之【巧妙隐藏桌面图标的进阶方案】

本文详细探讨了Android应用中隐藏桌面图标的进阶方案,解决了传统方法在Android 10及以上版本中出现的黑色图标残留问题。通过Intent-Filter配置和厂商适配技巧,实现子应用真正隐身,同时确保主应用正常启动。适用于企业工具套件、模块化系统等场景,提升用户体验和安全性。

weixin_28363123的博客 513

管理就是六个字:反复抓、抓反复

导读:从大量的企业案例可以清楚地知道,管理并没有那么神秘,很多成功企业的管理经验,用六个字就可以概括:反复抓,抓反复。是的,管理就是这么简单。作为企业的一名管理者,我们都清楚,当今有那么多的管理新概念、新理论、新方法、新工具,无时不在地游荡在我们的职场周围,它会通过各种信息渠道进入我们视野,给我们带来的不是兴奋,而是诚惶诚恐。是的,诚惶诚恐!为什么?因为我们在担心,我们自...

1898

支付逻辑漏洞的八大姿势(上篇)

学习支付漏洞,看这篇文章!!!文章来源:SecHub网络安全社区(本资料仅供学习参考,严禁使用者进行未授权渗透测试!严禁任何形式的转载!

qq_39493066的博客 1360

Halcon一维测量实战:从measure_pos与measure_pairs的底层原理到精准应用

本文深入解析Halcon中measure_pos与measure_pairs算子的底层原理与精准应用,涵盖参数调优、测量矩形方向设置及典型工业场景实战。通过对比分析,揭示两者在一维测量中的核心差异与适用场景,提供从基础到高级的完整解决方案,助力工业视觉检测精度提升。

weixin_42525551的博客 427

87.乐理基础-记号篇-反复记号(一)反复、跳房子

当前是写前两个记号,其余记号后面写:这些反复记号最主要的目的很简单,还是为了节约纸张,因为一首音乐无论是歌曲还是器乐曲什么的,经常会有反复的段落,那反复的段落如果在乐谱上又写一遍,不仅浪废纸张,而且写谱的人也很累,看谱的人也很累,必经以前没有电脑,没有打谱软件的时候是没办法直接复制粘贴的,所以就产生了很多反复记号,第一种反复记号,如图图1。图6:只会写后反复记号,就像下图的样子,所以见到这种只有一个后反复记号的乐谱时,就要知道,反复的起点就是乐谱的最开始,然后多个反复记号的乐谱例子,看图7。

计算机王的博客 1万+

24、水下传感器网络中混合LEACH协议与遗传算法获取路由节点

本文提出了一种结合遗传算法与LEACH协议的混合路由方案,用于提升水下无线传感器网络(UWSN)的能量利用效率和数据传输稳定性。通过遗传算法优化簇头选择与路径规划,有效避免节点过早死亡,减少能量消耗,在200个节点场景下显著提升网络寿命。相比传统LEACH协议,该方案具有更高的能量利用率、更强的环境适应性,并支持传输历史记录与并行传输序列。实验结果显示,该方案在总能量为2000焦耳时剩余能量达75.6%,远优于LEACH的34.8%能耗表现。适用于海洋监测、石油平台监控及水下灾害预警等复杂环境应用。

i8j9k0l1的博客 112

java 反复器_关于代码生成器反复生成代码的设计。

关于代码生成器反复生成代码的设计。我以前的做法是先生成尽可能详细的代码。(生成findby方法基本把每个字段都列在了查询条件里,包括一些基本用不到的)然后只需要复制其中的代码片断来完成需要新加的方法。前几天在表中增加字段之后,手工写了不少代码 :(((受 charon@xxx 的回复的提示,结合myeclipse生成 pojo的思路,对我的代码生成器进行改进,作以下处理。以dao为例(其它logi...

weixin_29317963的博客 226

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

反复反复再反复

学习是一个反复的过程,世上无难事,反复反复再反复,相信一切复杂的都会变得简单。           放正心态,自己不是一个聪明的人,不要强迫自己做到数一数二的人物。           但是,以自己不够长的人生经历来看,一般的事,都没有难倒过自己,所以反复反复再反复,一切都会变得简单而容易掌控。             生活中的很多例子。           有的人真

happy井二胖 383

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

反复修改才能创造出优秀的代码

反复修改才能创造出优秀的代码 近些年来,越来越多的人开始转向敏捷开发,而且这些敏捷开发的技术已不再新鲜,大多都是在80和90年代设计形成的。但是,最近几年,程序员,特别是一些商业顾问,架构师和客户开始喜欢上了敏捷开发。 不断进化的需求 现如今,有一个普遍的认识就是在你开始项目编程之前,你不可能写下所有的需求,这些需求的确定需要一个不断进化的过程。在较短的开发周期中,我们不断的完善程序,多次迭

php教程 364

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

java 反复器_8.3 枚举器(反复器)

## 8.3 枚举器(反复器)在任何集合类中,必须通过某种方法在其中置入对象,再用另一种方法从中取得对象。毕竟,容纳各种各样的对象正是集合的首要任务。在Vector中,addElement()便是我们插入对象采用的方法,而elementAt()是提取对象的唯一方法。Vector非常灵活,我们可在任何时候选择任何东西,并可使用不同的索引选择多个元素。若从更高的角度看这个问题,就会发现它的一个缺陷:需...

weixin_29261711的博客 131

好的代码,是不需要反复维护的代码

当然,只要业务需求不断变化,代码就不可能永远不动。我这里说的,是通过设计和编程手法,让代码尽可能稳定,让变化尽可能发生在代码之外。我之前写过一篇《适合中小型企业的出口入口网关微服务》,里面有一个很明显的特点:这个网关上线以后,半年甚至一年都不需要发布一次。这其实就是我理解的好代码。

Sam_Deep_Thinking 272

反复平方法求乘积

4:反复平方法计算幂次式p^n 这是本题关键所在,求n次幂方法的好坏,决定了本题是否TLE。 以p=2,n=8为例 常规是通过连乘法求幂,即2^8=2*2*2*2*2*2*2*2 这样做的要做8次乘法 而反复平方法则不同, 定义幂sq=1,再检查n是否大于0, While,循环过程若发现n为奇数,则把此时的p值乘到sq { ...

allia990718的博客 548

用反复平方法求幂运算

用反复平方法求幂运算:(M=Cd)   一、反复平方法求幂运算的算法: 设:d= (dndn-1… d1d0)2   方法一:(right toleft) M = 1; p = C; For i= 0 to n do : If(di==1) then M = M*p; endIf p=p*p; //之所以称之为反复平方法的缘由。 endFor

wzb56的资料库 3961
上一篇: Spring Boot + Mybatis 配合 AOP 和注解实现动态数据源切换配置
下一篇: 玩转 Java8 中的 Stream 之从零认识 Stream
公众号-芋道源码
博客等级 码龄10年 1639粉丝 377原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值