Service的绑定过程

news2024/11/15 11:18:32

前言

Service的绑定过程将分为两个部分来进行讲解；分别是Contextlmpl到AMS的调用过程和Service的绑定过程。

frameworks/base/core/java/android/content/ContextWrapper.java

 public boolean bindService(Intent service, ServiceConnection conn,
           int flags) {
       return mBase.bindService(service, conn, flags);
 }

通过Framework 学习之旅：Service 启动过程可知，mBase具体就是指向ContextImpl的,接着查看Contextlmpl的bindService方法：

frameworks/base/core/java/android/app/ContextImpl.java

public boolean bindService(Intent service, ServiceConnection conn, int flags) {
        warnIfCallingFromSystemProcess();
        return bindServiceCommon(service, conn, flags, null, mMainThread.getHandler(), null,
                getUser());//1
}

private boolean bindServiceCommon(Intent service, ServiceConnection conn, int flags,
            String instanceName, Handler handler, Executor executor, UserHandle user) {
    IServiceConnection sd;
    ....
    if (mPackageInfo != null) {
       if (executor != null) {
            sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), executor, flags);
        } else {
            sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);//2
        }           
    } else {
            throw new RuntimeException("Not supported in system context");
    }
    validateServiceIntent(service);
    try {
            // activity在系统端的 token
        IBinder token = getActivityToken();
        if (token == null && (flags&BIND_AUTO_CREATE) == 0 && mPackageInfo != null
                    && mPackageInfo.getApplicationInfo().targetSdkVersion
                    < android.os.Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
            flags |= BIND_WAIVE_PRIORITY;
        }
        service.prepareToLeaveProcess(this);
        // 调用 AMS 
        int res = ActivityManager.getService().bindIsolatedService(
            mMainThread.getApplicationThread(), getActivityToken(), service,
            service.resolveTypeIfNeeded(getContentResolver()),
            sd, flags, instanceName, getOpPackageName(), user.getIdentifier());//3
        if (res < 0) {
            throw new SecurityException(
                    "Not allowed to bind to service " + service);
        }
        return res != 0;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }        

}

在注释1处，bindService方法又调用了bindServiceCommon方法；

在注释2处，调用了LoadedApk类型的对象mPackagelnfo的getServiceDispatcher方法；它的主要作用是将ServiceConnection封装为IServiceConnection类型的对象sd，从IServiceConnection的名字我们就能得知它实现了Binder机制，这样Service的绑定就支持了跨进程。

在注释3处，调用AMS的bindIsolatedService方法。下面，先继续查看LoadedApk的getServiceDispatcher方法

frameworks/base/core/java/android/app/LoadedApk.java

@UnsupportedAppUsage
  public final IServiceConnection getServiceDispatcher(ServiceConnection c,
          Context context, Handler handler, int flags) {
      return getServiceDispatcherCommon(c, context, handler, null, flags);
  }

  public final IServiceConnection getServiceDispatcher(ServiceConnection c,
          Context context, Executor executor, int flags) {
      return getServiceDispatcherCommon(c, context, null, executor, flags);
  }

 private IServiceConnection getServiceDispatcherCommon(ServiceConnection c,
            Context context, Handler handler, Executor executor, int flags) {
    synchronized (mServices) {
            LoadedApk.ServiceDispatcher sd = null;
            // 注释1
            ArrayMap<ServiceConnection, LoadedApk.ServiceDispatcher> map = mServices.get(context);
            if (map != null) {
                if (DEBUG) Slog.d(TAG, "Returning existing dispatcher " + sd + " for conn " + c);
                sd = map.get(c);
            }
            if (sd == null) {
                if (executor != null) {
                    sd = new ServiceDispatcher(c, context, executor, flags);
                } else {
                    sd = new ServiceDispatcher(c, context, handler, flags);//注释2
                }
                if (DEBUG) Slog.d(TAG, "Creating new dispatcher " + sd + " for conn " + c);
                if (map == null) {
                    map = new ArrayMap<>();
                    mServices.put(context, map);
                }
                map.put(c, sd);
            } else {
                sd.validate(context, handler, executor);
            }
             // 返回的是 InnerConnection 对象
            return sd.getIServiceConnection();
    }                   
 }

由源码可知，注释1处mServices通过context获取对应的ServiceConnection和ServiceDispatcher。注释2处新建ServiceDispatcher对象，并且将参数传入构造方法中，最终通过ServiceDispatcher对象来获取IServiceConnection。

下面接着看LoadApk的内部静态类ServiceDispatcher:

frameworks/base/core/java/android/app/LoadedApk.java

static final class ServiceDispatcher {
    private final ServiceDispatcher.InnerConnection mIServiceConnection;
    private final ServiceConnection mConnection;
    private final Context mContext;
    private final Handler mActivityThread;
    private final Executor mActivityExecutor;
    private final ServiceConnectionLeaked mLocation;
    private final int mFlags;
        .....
    
    private static class InnerConnection extends IServiceConnection.Stub {
        @UnsupportedAppUsage
        final WeakReference<LoadedApk.ServiceDispatcher> mDispatcher;

        InnerConnection(LoadedApk.ServiceDispatcher sd) {
            mDispatcher = new WeakReference<LoadedApk.ServiceDispatcher>(sd);
        }
        
        public void connected(ComponentName name, IBinder service, boolean dead)
                    throws RemoteException {
            LoadedApk.ServiceDispatcher sd = mDispatcher.get();
            if (sd != null) {
                // 回调 connected()方法 
                sd.connected(name, service, dead);
            }
        }
        .....           
    }
    
    @UnsupportedAppUsage
    ServiceDispatcher(ServiceConnection conn,
                Context context, Handler activityThread, int flags) {
         mIServiceConnection = new InnerConnection(this);
        mConnection = conn;
        mContext = context;
        mActivityThread = activityThread;
        mActivityExecutor = null;
        mLocation = new ServiceConnectionLeaked(null);
        mLocation.fillInStackTrace();
        mFlags = flags;
    }
      ......
      
    @UnsupportedAppUsage
    IServiceConnection getIServiceConnection() {
        return mIServiceConnection;
    }

}

由源码可知，ServiceDispatcher构造方法中传入主线程的activityThread和context包装到ServiceDispatcher对象中，并在内部实现了IServiceConnection接口的InnerConnection，最终通过getIServiceConnection方法返回将其赋值给最开始创建的sd对象，也就是可以和远程服务进行Binder通信的本地引用。

时序图：

在这里插入图片描述

AMS到ActivityThread启动绑定Service过程

接着分析，ActivityManagerService的bindIsolatedService方法：

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public int bindIsolatedService(IApplicationThread caller, IBinder token, Intent service,
            String resolvedType, IServiceConnection connection, int flags, String instanceName,
            String callingPackage, int userId) throws TransactionTooLargeException {
        enforceNotIsolatedCaller("bindService");
        ......
        synchronized(this) {
            // token: Activity在系统中Token对象
            // connection：客户端提供的 Binder 对象
            return mServices.bindServiceLocked(caller, token, service,
                    resolvedType, connection, flags, instanceName, callingPackage, userId);
        }
    }

bindIsolatedService方法中调用了ActiveServices类的bindServiceLocked方法。

frameworks/base/services/core/java/com/android/server/am/ActiveServices.java

int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service,
            String resolvedType, final IServiceConnection connection, int flags,
            String instanceName, String callingPackage, final int userId)
            throws TransactionTooLargeException {
    
    // 获取调用者进程对象ProcessRecord 
    final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
    .....
    
    ActivityServiceConnectionsHolder<ConnectionRecord> activity = null;
    // 如果token不为null，则表示是activity中bindservice的
    if (token != null) {
       // 根据传递过来的token，获取activity对象，为空则表示在系统端没有注册，是非法的，直接结束。
        activity = mAm.mAtmInternal.getServiceConnectionsHolder(token);
        if (activity == null) {
            Slog.w(TAG, "Binding with unknown activity: " + token);
            return 0;
        }
    }
    .....
    // 通过PMS解析获取 ServiceRecord 信息
    ServiceLookupResult res =
            retrieveServiceLocked(service, instanceName, resolvedType, callingPackage,
                    Binder.getCallingPid(), Binder.getCallingUid(), userId, true,
                    callerFg, isBindExternal, allowInstant);
    .....
    // 得到ServiceRecord 对象 
    ServiceRecord s = res.record;
    .....
    // 得到AppBindRecord对象，表示该服务对应的其中一个客户端(一个服务可以被多个客户端绑定)
    // 注释0
    AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
    //创建ConnectionRecord对象，封装从绑定服务的发起端传递过来的conn
    ConnectionRecord c = new ConnectionRecord(b, activity,
                    connection, flags, clientLabel, clientIntent,
                    callerApp.uid, callerApp.processName, callingPackage);
    .....
    IBinder binder = connection.asBinder();
    s.addConnection(binder, c); 
    b.connections.add(c);
    if (activity != null) { 
        activity.addConnection(c);
    }
    b.client.connections.add(c);
    c.startAssociationIfNeeded();
    .....
    ArrayList<ConnectionRecord> clist = mServiceConnections.get(binder);
    if (clist == null) {
        clist = new ArrayList<>();
        mServiceConnections.put(binder, clist);
    }
    clist.add(c);
    .....
    // 如果设置了BIND_AUTO_CREATE 标志
    if ((flags&Context.BIND_AUTO_CREATE) != 0) {
       s.lastActivity = SystemClock.uptimeMillis();
        // 开始启动 service
       if (bringUpServiceLocked(s, service.getFlags(), callerFg, false,
            permissionsReviewRequired) != null) {// 1
                return 0;
            }
    }
    .....
    if (s.app != null && b.intent.received) {// 2
        // Service is already running, so we can immediately
        // publish the connection.
        try {
            // 服务已经发布，通过binder调用发起端的connected()方法
            c.conn.connected(s.name, b.intent.binder, false);//3
        } catch (Exception e) {
            Slog.w(TAG, "Failure sending service " + s.shortInstanceName
                            + " to connection " + c.conn.asBinder()
                            + " (in " + c.binding.client.processName + ")", e);
        }

        // If this is the first app connected back to this binding,
        // and the service had previously asked to be told when
        // rebound, then do so.
        if (b.intent.apps.size() == 1 && b.intent.doRebind) {//4
            // 如果已经bind过，则回调onReBind
            requestServiceBindingLocked(s, b.intent, callerFg, true);//5
        }
    } else if (!b.intent.requested) {//6
        // 最终回调 onBind() 方法
       requestServiceBindingLocked(s, b.intent, callerFg, false);//7
    }
    .....
}

在注释0处调用了ServiceRecord的retrieveAppBindingLocked方法来获得AppBindRecord , retrieveAppBindingLocked方法内部创建IntentBindRecord，并对IntentBindRecord的成员变量进行赋值。

在注释1处调用bringUpServiceLocked方法，在bringUpServiceLocked方法中又调用realStartServiceLocked方法，最终由ActivityThread来调用Service的onCreate方法启动Service，这也说明了bindService方怯内部会启动Service。

在注释2处s.app!=null表示Service已经运行，其中s是ServiceRecord类型对象，app是ProcessRecord类型对象。b.intent.received表示当前应用程序进程已经接收到绑定Service时返回的Binder，这样应用程序进程就可以通过Binder获取要绑定的Service的访问接口。

在注释3处调用conn.connected方法，其中c.conn指的是IServiceConnection，它的具体实现为 ServiceDispatcher.InnerConnection，其中ServiceDispatcher是Loaded.Apk的内部类，InnerConnection的connected方法内部会调用H的post方法向主线程发送消息，并且解决当前应用程序进程Service跨进程通信的问题。

在注释4处如果当前应用程序进程是第一个与Service进行绑定的，并且Service已经调用过onUnBind方法，则需要调用注释5处的代码。

在注释6处如果应用程序进程的Client端没有发送过绑定Service的请求，则调用注释7处的代码，注释7处和注释5处的代码区别就是最后一个参数rebind为false，表 示不是重新绑定。

首先查看bindServiceLocked方法注释0处ServiceRecord的retrieveAppBindingLocked方法：

frameworks/base/services/core/java/com/android/server/am/ServiceRecord.java

final ArrayMap<Intent.FilterComparison, IntentBindRecord> bindings
            = new ArrayMap<Intent.FilterComparison, IntentBindRecord>();

public AppBindRecord retrieveAppBindingLocked(Intent intent,
            ProcessRecord app) {
        Intent.FilterComparison filter = new Intent.FilterComparison(intent);
        IntentBindRecord i = bindings.get(filter);
        if (i == null) {//1
            i = new IntentBindRecord(this, filter);
            bindings.put(filter, i);
        }
        AppBindRecord a = i.apps.get(app);//2
        if (a != null) {
            return a;
        }
        a = new AppBindRecord(this, i, app);//3
        i.apps.put(app, a);
        return a;
}

注释1处通过filter查找对应IntentBindRecord类型的i,如果i为null意味着当前应用程序进程没有绑定服务，那就新建了IntentBindRecord并保持；

注释2处根据ProcessRecord获得IntentBindRecord中存储的AppBindRecord,如果 AppBindRecord不为null就返回,如果为null就在注释3处创建AppBindRecord，并将 ProcessRecord作为key,AppBindRecord作为value保存在IntentBindRecord的apps (i.apps）中。

接着，bindServiceLocked方法注释1处在Service启动过程 已经分析过了，在此就不展开分析了。重点分析bindServiceLocked方法的注释5和注释7处的requestServiceBindingLocked方法：

frameworks/base/services/core/java/com/android/server/am/ActiveServices.java

private final boolean requestServiceBindingLocked(ServiceRecord r, IntentBindRecord i,
            boolean execInFg, boolean rebind) throws TransactionTooLargeException {
        .......
        if ((!i.requested || rebind) && i.apps.size() > 0) {//1
            try {
                bumpServiceExecutingLocked(r, execInFg, "bind");
                r.app.forceProcessStateUpTo(ActivityManager.PROCESS_STATE_SERVICE);
                r.app.thread.scheduleBindService(r, i.intent.getIntent(), rebind,
                        r.app.getReportedProcState());//2
                if (!rebind) {
                    i.requested = true;
                }
                i.hasBound = true;
                i.doRebind = false;
            } catch (TransactionTooLargeException e) {
                ....
            } catch (RemoteException e) {
               ....
            }
        }
        return true;
    }

注释1处i.requested 表示是否发送过绑定Service的请求，从bindServiceLocked 方法的注释4处得知是发送过的，因此，!i.requested为false。从bindServiceLocked方法的注释4处得知rebind值为true，那么（！i.requested||rebind）的值为true。i.apps.size()>0表示所有用当前Intent绑定Service的应用程序进程个数大于0。其中i是IntentBindRecord 类型的对象，AMS会为每个绑定Service的Intent 分配一个IntentBindRecord类型对象。具体看一下IntentBindRecord类型：

frameworks/base/services/core/java/com/android/server/am/IntentBindRecord.java

final class IntentBindRecord {
    // 被绑定的Service
    final ServiceRecord service;
    // 绑定Service的intent
    final Intent.FilterComparison intent;
    // 所有用当前Intent绑定Service 的应用程序
    final ArrayMap<ProcessRecord, AppBindRecord> apps
            = new ArrayMap<ProcessRecord, AppBindRecord>();//1
    ....        
}

来查看IntentBindRecord类，不同的应用程序进程可能使用同Intent来绑定Service，因此在注释1处会用apps来存储所有用当前Intent绑定Service的应用程序进程。

下面，接着看requestServiceBindingLocked方法注释2处代码：

frameworks/base/core/java/android/app/ActivityThread.java

public final void scheduleBindService(IBinder token, Intent intent,
                boolean rebind, int processState) {
    updateProcessState(processState, false);
    BindServiceData s = new BindServiceData();
    s.token = token;
    s.intent = intent;
    s.rebind = rebind;

    if (DEBUG_SERVICE)
        Slog.v(TAG, "scheduleBindService token=" + token + " intent=" + intent + " uid="
        + Binder.getCallingUid() + " pid=" + Binder.getCallingPid());
    sendMessage(H.BIND_SERVICE, s);
}

public void handleMessage(Message msg) {
    switch (msg.what) {
        case BIND_SERVICE:
             Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "serviceBind");
             handleBindService((BindServiceData)msg.obj); //1
             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
             break;
    }
}

在scheduleBindService方法中将Service的信息封装成BindServiceData对象， BindServiceData的成员变量rebind值为false。接着将BindServiceData传入到 sendMessage方法中。H在接收到BIND_ERVICE类型消息时，会在handleMessage 方法中会调用handleBindService方法：

frameworks/base/core/java/android/app/ActivityThread.java

private void handleBindService(BindServiceData data) {
        Service s = mServices.get(data.token);//1
        if (DEBUG_SERVICE)
            Slog.v(TAG, "handleBindService s=" + s + " rebind=" + data.rebind);
        if (s != null) {
            try {
                data.intent.setExtrasClassLoader(s.getClassLoader());
                data.intent.prepareToEnterProcess();
                try {
                    if (!data.rebind) {//2
                        IBinder binder = s.onBind(data.intent);//3
                        ActivityManager.getService().publishService(
                                data.token, data.intent, binder);//4
                    } else {
                        s.onRebind(data.intent);//5
                        ActivityManager.getService().serviceDoneExecuting(
                                data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
                    }
                } catch (RemoteException ex) {
                    throw ex.rethrowFromSystemServer();
                }
            } catch (Exception e) {
                if (!mInstrumentation.onException(s, e)) {
                    throw new RuntimeException(
                            "Unable to bind to service " + s
                            + " with " + data.intent + ": " + e.toString(), e);
                }
            }
        }
    }

在注释1处获取要绑定的Service。注释2处的BindServiceData的成员变量rebind的值为false，这样调用注释3处的代码来调用Service的onBind方法，到这里Service 处于绑定状态了。如果rebind的值为true就调用注释5处的Service的onRebind方法，结合前文的bindServiceLocked方法的注释4处，得出的结论就是：如果当前应用程序进程第一个与Service进行绑定，并且Service调用过onUnBind方法，则调用 Service的onRebind方法。

frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java

public void publishService(IBinder token, Intent intent, IBinder service) {
        // Refuse possible leaked file descriptors
        ......

        synchronized(this) {
            if (!(token instanceof ServiceRecord)) {
                throw new IllegalArgumentException("Invalid service token");
            }
            mServices.publishServiceLocked((ServiceRecord)token, intent, service);//1
        }
}

在publishService方法中调用ActiveServices类型的mService对象的publishServiceLocked方法：

frameworks/base/services/core/java/com/android/server/am/ActiveServices.java

void publishServiceLocked(ServiceRecord r, Intent intent, IBinder service) {
    try {
        ....
        ArrayMap<IBinder, ArrayList<ConnectionRecord>> connections = r.getConnections();
        for (int conni = connections.size() - 1; conni >= 0; conni--) {
            .....
            ConnectionRecord c = clist.get(i);
            try {
                // 回调app端的 IServiceConnection的 connected()方法 
                c.conn.connected(r.name, service, false);//1
            } catch (Exception e) {
                Slog.w(TAG, "Failure sending service " + r.shortInstanceName
                                      + " to connection " + c.conn.asBinder()
                                      + " (in " + c.binding.client.processName + ")", e);
            }
            serviceDoneExecutingLocked(r, mDestroyingServices.contains(r), false);
        }
    }finally {
        Binder.restoreCallingIdentity(origId);
    }
}

注释1处c.conn指的是IServiceConnection，它是ServiceConnection在本地的代理，用于解决当前应用程序进程和Service跨进程通信的问题，具体实现为ServiceDispatcher.InnerConnection,其中ServiceDispatcher是LoadedApk的内部类，查看ServiceDispatcher.InnerConnection的connected方法：

frameworks/base/core/java/android/app/LoadedApk.java

static final class ServiceDispatcher {

    private final ServiceDispatcher.InnerConnection mIServiceConnection;
    ......
    
    private static class InnerConnection extends IServiceConnection.Stub {
        @UnsupportedAppUsage
        final WeakReference<LoadedApk.ServiceDispatcher> mDispatcher;

        InnerConnection(LoadedApk.ServiceDispatcher sd) {
                mDispatcher = new WeakReference<LoadedApk.ServiceDispatcher>(sd);
        }

        public void connected(ComponentName name, IBinder service, boolean dead)
                    throws RemoteException {
            LoadedApk.ServiceDispatcher sd = mDispatcher.get();
            if (sd != null) {
                sd.connected(name, service, dead); //1
            }
        }
    }
    
    .....
    
    public void connected(ComponentName name, IBinder service, boolean dead) {
        if (mActivityExecutor != null) {
            mActivityExecutor.execute(new RunConnection(name, service, 0, dead));
        } else if (mActivityThread != null) {
            mActivityThread.post(new RunConnection(name, service, 0, dead));//2
        } else {
            doConnected(name, service, dead);
        }
    }
    
    .....
    
}

在注释1处调用了ServiceDispatcher类型的sd对象的connected方法。

在注释2处调用Handler类型的对象mActivityThread的post方法，mActivityThread实际上是指向的H。因此,通过调用post方法将RunConnection对象的内容运行在主线程中。RunConnection是LoadedApk的内部类：

frameworks/base/core/java/android/app/LoadedApk.java

private final class RunConnection implements Runnable {
            RunConnection(ComponentName name, IBinder service, int command, boolean dead) {
                mName = name;
                mService = service;
                mCommand = command;
                mDead = dead;
            }

            public void run() {
                if (mCommand == 0) {
                    doConnected(mName, mService, mDead);//1
                } ....
            }

           ...
        }
        
 public void doConnected(ComponentName name, IBinder service, boolean dead) {
            ServiceDispatcher.ConnectionInfo old;
            ServiceDispatcher.ConnectionInfo info;

            .....
            // If there is a new viable service, it is now connected.
            if (service != null) {
                mConnection.onServiceConnected(name, service);//2
            } else {
                // The binding machinery worked, but the remote returned null from onBind().
                mConnection.onNullBinding(name);
            }
}

在注释1处RunConnection的run方法中调用了doConnected方法；在注释2处调用了ServiceConnection类型的对象mConnection的onServiceConnected方法，这样在客户端实现了ServiceConnection 接口类的onServiceConnected方法就会被执行，传入是服务端的服务名字和服务Binder对象。至此，Service的绑定过程就分析完成。

时序图：

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/98770.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

计算机毕设Python+Vue-新型冠状病毒防控咨询网站（程序+LW+部署）

计算机毕设Python+Vue-新型冠状病毒防控咨询网站（程序+LW+部署）

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…
阅读更多...
根据端口划分虚拟局域、集线器、中继器、交换机、路由器、网桥----计算机网络

根据端口划分虚拟局域、集线器、中继器、交换机、路由器、网桥----计算机网络

集线器&#xff1a; 连接计算机和交换机&#xff0c;类似于多台中继器。 实现多台电脑的同时使用一个进线接口来上网或组成局域网 中继器&#xff1a; 连接两条电缆&#xff0c;作用是放大前一条电缆里面的信号并传入下一条电缆。 是对接收到的信息进行再生放大&#xff0c;以…
阅读更多...
Jenkins + Jmeter + Ant 持续集成

Jenkins + Jmeter + Ant 持续集成

搭建提前安装好&#xff1a;ant Jenkins 环境 一、Jenkins 安装 Ant 插件&#xff1a; 进入Jenkins 配置插件页面&#xff0c;安装ant 插件&#xff1a; 打开插件配置页面&#xff0c;如下图&#xff1a; 点击“Available” 在输入框搜索 ant 安装即可&#xff1a; 二、安装…
阅读更多...
计算机毕业设计springboot+vue基本微信小程序的透析耗材管理系统

计算机毕业设计springboot+vue基本微信小程序的透析耗材管理系统

项目介绍 随着信息技术和网络技术的飞速发展,人类已进入全新信息化时代,传统管理技术已无法高效,便捷地管理信息。为了迎合时代需求,优化管理效率,各种各样的管理程序应运而生,各行各业相继进入信息管理时代,透析耗材管理小程序就是信息时代变革中的产物之一。 任何程序都要遵循…
阅读更多...
vue前端案例教学：动态获取最新疫情数据展示（代码详解）

vue前端案例教学：动态获取最新疫情数据展示（代码详解）

【辰兮要努力】&#xff1a;hello你好我是辰兮&#xff0c;很高兴你能来阅读&#xff0c;昵称是希望自己能不断精进&#xff0c;向着优秀程序员前行&#xff01; 博客来源于项目以及编程中遇到的问题总结&#xff0c;偶尔会有读书分享&#xff0c;我会陆续更新Java前端、后台、…
阅读更多...
[leetcode.4]寻找两个正序数组的中位数 多思考边界

[leetcode.4]寻找两个正序数组的中位数 多思考边界

题目展示 题目要点 题目其实本身的思路非常简单&#xff0c;就是把两个数组给合并起来&#xff0c;然后寻找中位数&#xff0c;具体可以参考我们使用归并排序时候的最后一步&#xff0c;这题的难点其实在于&#xff08;1&#xff09;时间压缩到lognm&#xff08;2&#xff09;…
阅读更多...
[附源码]Nodejs计算机毕业设计基于与协同过滤算法的竞赛项目管理Express(程序+LW)

[附源码]Nodejs计算机毕业设计基于与协同过滤算法的竞赛项目管理Express(程序+LW)

该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程。欢迎交流 项目运行 环境配置&#xff1a; Node.js Vscode Mysql5.7 HBuilderXNavicat11VueExpress。 项目技术&#xff1a; Express框架 Node.js Vue 等等组成&#xff0c;B/S模式 Vscode管理前后端分…
阅读更多...
基于MMEngine和MMDet搭建目标跟踪框架MMTracking-1.0.0rc1-Win10

基于MMEngine和MMDet搭建目标跟踪框架MMTracking-1.0.0rc1-Win10

缘由&#xff1a; 1. 目标跟踪是工业检测和学术研究的基础课题&#xff0c;其pipeline通常分为视频目标检测、视频实例分割、单目标跟踪、多目标跟踪和Re-ID五类&#xff0c;同时&#xff0c;还细分为在线检测和离线检测两种任务模式。由于现阶段关于目标跟踪的教程较少&#…
阅读更多...
机器学习 KNN算法原理

机器学习 KNN算法原理

目录 一&#xff1a;KNN算法概念 二&#xff1a;KNN原理 三&#xff1a;KNN超参数 四&#xff1a;KNN算法选择 一&#xff1a;KNN算法概念 KNN(K-Nearest Neighbor)法即K最邻近法&#xff0c;最初由Cover和Hart于1968年提出&#xff0c;是最简单的机器学习算法之一 算法思路…
阅读更多...
NNDL 作业9：分别使用numpy和pytorch实现BPTT

NNDL 作业9：分别使用numpy和pytorch实现BPTT

6-1P&#xff1a;推导RNN反向传播算法BPTT. 6-2P&#xff1a;设计简单RNN模型&#xff0c;分别用Numpy、Pytorch实现反向传播算子&#xff0c;并代入数值测试.、 forward&#xff1a; 我们知道循环卷积网络的cell的计算公式为&#xff1a; stf(UxtWst−1)\mathrm{s}_tf(…
阅读更多...
UML学习入门

UML学习入门

UML 举一个简单的例子&#xff0c;来看这样一副图&#xff0c;其中就包括了UML类图中的基本图示法。 首先&#xff0c;看动物矩形框&#xff0c;它代表一个类&#xff08;Class&#xff09;。类图分三层&#xff0c;第一层显示类的名称&#xff0c;如果是抽象类&#xff0c;则…
阅读更多...
多模块之前的消息引用问题

多模块之前的消息引用问题

多模块引用之前的问题目录概述需求&#xff1a;设计思路实现思路分析1.在第一个模块中调用另一个调用模块的Bean2.普通java类 如何获取另一个模块的Bean3.启用消息机制4.为什么普通java类很难调用SpringBean的&#xff1f;参考资料和推荐阅读Survive by day and develop by nig…
阅读更多...
机器学习快速上手基础

机器学习快速上手基础

努力是为了不平庸~ 学习的最大理由是想摆脱平庸&#xff0c;早一天就多一份人生的精彩&#xff1b;迟一天就多一天平庸的困扰。 目录 一、简介与应该明确的学习方法 1、学习方法 2、简介 二、学习机器学习的优势 三、机器学习的内核 1、学习术语 2、内核 四、机器学习…
阅读更多...
IT团队自动化端点管理解决方案—基于虹科Chef工具

IT团队自动化端点管理解决方案—基于虹科Chef工具

企业如何简化端点管理工作流程&#xff1f; 如何解决安全事件&#xff1f;如何生成审计报告&#xff1f;如何处理大量账单&#xff1f;这些都是企业IT团队需要考虑的问题。然而&#xff0c;IT人员每天有大量的事情需要处理&#xff0c;如何自动化、标准化、及时性的处理这些问…
阅读更多...
（最优化理论与方法）第六章无约束优化算法-第二节：梯度类算法

（最优化理论与方法）第六章无约束优化算法-第二节：梯度类算法

文章目录一&#xff1a;次梯度算法&#xff08;1&#xff09;次梯度算法结构&#xff08;2&#xff09;应用举例-LASSO问题求解二&#xff1a;牛顿法&#xff08;1&#xff09;经典牛顿法&#xff08;2&#xff09;修正牛顿法三&#xff1a;拟牛顿法&#xff08;1&#xff09;拟…
阅读更多...
知到/智慧树——英语听说：实境主题与技能（参考答案）

知到/智慧树——英语听说：实境主题与技能（参考答案）

目录 第一章测试 第二章测试 第三章测试 第四章测试 第五章测试 第六章测试 第七章测试 第八章测试 第九章测试 第十章测试 第一章测试 第1部分总题数: 10 1 【多选题】 (10分) What does this chapter mainly teach &#xff08; &#xff09;&#xff1f; A. T…
阅读更多...
生成树（基础）

生成树（基础）

目录 一、生成树的相关概念 二、最小生成树的相关概念 最小生成树的性质(MST性质)&#xff1a; MST性质解释&#xff1a; 三、Prim算法&#xff08;普里姆算法&#xff09; 动态演示 关键算法&#xff1a; 完整代码&#xff1a; 四、Kruskal(克鲁斯卡尔)算法 动态演示&…
阅读更多...
mysql主从复制架构

mysql主从复制架构

MySQL的主从复制架构的分布机制&#xff0c;是通过将MySQL的某一台主机(master)的数据复制到其他主机(slave)上。 在复制过程中一台主机作为主服务器&#xff0c;其他服务器则为从服务器。主服务器将更新写入到日志文件中&#xff0c;日志被从服务器的 I/O线程读取&#xff0c;…
阅读更多...
逻辑回归 预测癌症数据

逻辑回归 预测癌症数据

目录 一&#xff1a;加载数据 二&#xff1a;数据集划分 三&#xff1a;选择算法 四&#xff1a;网格模型 超参调优 五&#xff1a;模型预测 六&#xff1a;模型保存和使用 七&#xff1a;完整源码分享 八&#xff1a;预测与实际比对 一&#xff1a;加载数据 from sk…
阅读更多...
C语言—变量与常量

C语言—变量与常量

想存储一个数据时&#xff0c;都会在内存中开辟一个空间&#xff0c;这个空间会有一个地址&#xff1b; 这个地址是一串数字&#xff0c;为了方便记忆&#xff0c;所以要对这个地址起一个名字&#xff0c;也就是变量名&#xff1b; 通过这个变量名就可以找到内存中存放这个数…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023