isLJli
isLJli

Binder 应用层-AIDL原理

Binder系列：
Binder Kernel层—Binder内核驱动
Binder Native层—服务管理(ServiceManager进程)
Binder Native层—注册/查询服务
Binder Framework层—注册和查询服务
Binder 应用层-AIDL原理

AIDL概述

本篇文章讲解AIDL的原理，对于AIDL的使用详解可参考文档Android 接口定义语言 (AIDL)和Android AIDL使用详解

AIDL支持的数据类型：

  1. 8种基本的数据类型：int、long、float、double、char、byte、short、boolean。
  2. String、CharSequence
  3. List、Map
  4. 声明为parcelable的aidl接口，先创建一个aidl接口，然后重建一个同名的java类并实现Parcelable序列化。
// aidl接口
parcelable Book;

// java类
public class Book implements Parcelable {
  private String name;
  // ...
  protected Book(Parcel in) {
      this.name = in.readString();
  }

  public static final Creator CREATOR = new Creator() {
      @Override
      public Book createFromParcel(Parcel in) {
          return new Book(in);
      }

      @Override
      public Book[] newArray(int size) {
          return new Book[size];
      }
  };

  @Override
  public int describeContents() {
      return 0;
  }

  @Override
  public void writeToParcel(Parcel parcel, int i) {
      parcel.writeString(name);
  }


  public void readFromParcel(Parcel dest) {
      name = dest.readString();
  }

}

AIDL的使用流程：

  1. AIDL是一种模版接口，通过该接口定义Server端对外提供的方法。AIDL接口通过syn gradle自动生成一个Service端的Binder对象Stub，和一个client端的代理对象Proxy。
// BookController.aidl
package com.czy.server;
import com.czy.server.Book;

// Declare any non-default types here with import statements

interface BookController {
    List getBookList();
   void addBookInOut(inout Book book);

   void addBookIn(in Book book);

   void addBookOut(out Book book);
}

// 自动生成一个Java类
public interface BookController extends android.os.IInterface
{

/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.czy.server.BookController
{
  private static final java.lang.String DESCRIPTOR = "com.czy.server.BookController";
  /** Construct the stub at attach it to the interface. */
  public Stub()
  {
    this.attachInterface(this, DESCRIPTOR);
  }
  /**
   * Cast an IBinder object into an com.czy.server.BookController interface,
   * generating a proxy if needed.
   */
  public static com.czy.server.BookController asInterface(android.os.IBinder obj)
  {
    if ((obj==null)) {
      return null;
    }
    android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
    if (((iin!=null)&&(iin instanceof com.czy.server.BookController))) {
      return ((com.czy.server.BookController)iin);
    }
    return new com.czy.server.BookController.Stub.Proxy(obj);
  }
  @Override public android.os.IBinder asBinder()
  {
    return this;
  }
  @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
  {
    java.lang.String descriptor = DESCRIPTOR;
    switch (code)
    {
      case INTERFACE_TRANSACTION:
      {
        reply.writeString(descriptor);
        return true;
      }
      case TRANSACTION_getBookList:
      {
        data.enforceInterface(descriptor);
        java.util.List _result = this.getBookList();
        reply.writeNoException();
        reply.writeTypedList(_result);
        return true;
      }
      case TRANSACTION_addBookInOut:
      {
        data.enforceInterface(descriptor);
        com.czy.server.Book _arg0;
        if ((0!=data.readInt())) {
          _arg0 = com.czy.server.Book.CREATOR.createFromParcel(data);
        }
        else {
          _arg0 = null;
        }
        this.addBookInOut(_arg0);
        reply.writeNoException();
        if ((_arg0!=null)) {
          reply.writeInt(1);
          _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        }
        else {
          reply.writeInt(0);
        }
        return true;
      }
      case TRANSACTION_addBookIn:
      {
        data.enforceInterface(descriptor);
        com.czy.server.Book _arg0;
        if ((0!=data.readInt())) {
          _arg0 = com.czy.server.Book.CREATOR.createFromParcel(data);
        }
        else {
          _arg0 = null;
        }
        this.addBookIn(_arg0);
        reply.writeNoException();
        return true;
      }
      case TRANSACTION_addBookOut:
      {
        data.enforceInterface(descriptor);
        com.czy.server.Book _arg0;
        _arg0 = new com.czy.server.Book();
        this.addBookOut(_arg0);
        reply.writeNoException();
        if ((_arg0!=null)) {
          reply.writeInt(1);
          _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        }
        else {
          reply.writeInt(0);
        }
        return true;
      }
      default:
      {
        return super.onTransact(code, data, reply, flags);
      }
    }
  }
  private static class Proxy implements com.czy.server.BookController
  {
    private android.os.IBinder mRemote;
    Proxy(android.os.IBinder remote)
    {
      mRemote = remote;
    }
    @Override public android.os.IBinder asBinder()
    {
      return mRemote;
    }
    public java.lang.String getInterfaceDescriptor()
    {
      return DESCRIPTOR;
    }
    @Override public java.util.List getBookList() throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      java.util.List _result;
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        boolean _status = mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          return getDefaultImpl().getBookList();
        }
        _reply.readException();
        _result = _reply.createTypedArrayList(com.czy.server.Book.CREATOR);
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
      return _result;
    }
    @Override public void addBookInOut(com.czy.server.Book book) throws android.os.RemoteException
    {
      //...
    }
    @Override public void addBookIn(com.czy.server.Book book) throws android.os.RemoteException
    {
      //...
    }
    @Override public void addBookOut(com.czy.server.Book book) throws android.os.RemoteException
    {
     //...
    }
    public static com.czy.server.BookController sDefaultImpl;
  }
  static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
  static final int TRANSACTION_addBookInOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
  static final int TRANSACTION_addBookIn = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
  static final int TRANSACTION_addBookOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
  public static boolean setDefaultImpl(com.czy.server.BookController impl) {
    // Only one user of this interface can use this function
    // at a time. This is a heuristic to detect if two different
    // users in the same process use this function.
    if (Stub.Proxy.sDefaultImpl != null) {
      throw new IllegalStateException("setDefaultImpl() called twice");
    }
    if (impl != null) {
      Stub.Proxy.sDefaultImpl = impl;
      return true;
    }
    return false;
  }
  public static com.czy.server.BookController getDefaultImpl() {
    return Stub.Proxy.sDefaultImpl;
  }
}
public java.util.List getBookList() throws android.os.RemoteException;
public void addBookInOut(com.czy.server.Book book) throws android.os.RemoteException;
public void addBookIn(com.czy.server.Book book) throws android.os.RemoteException;
public void addBookOut(com.czy.server.Book book) throws android.os.RemoteException;
}
  1. Service端通过建立一个Service，在其onBind方法中返回AIDL接口自动生成的Binder对象(Stub),并实现Server端对外提供的方法。
public class AIDLService extends Service {

   //... 
  private final BookController.Stub stub = new BookController.Stub() {
      @Override
      public List getBookList() throws RemoteException {
          return bookList;
      }
      // ... 接口方法的实现
  };


  @Nullable
  @Override
  public IBinder onBind(Intent intent) {
      return stub;
  }

}
  1. Client通过启动Server端的Service，并利用ServiceConnection进行监听获取到Client端的代理对象Proxy，并通过Proxy进行对Server方法的调用。
 private val serviceConnection = object : ServiceConnection {
      override fun onServiceConnected(p0: ComponentName?, p1: IBinder?) {
          bookController = BookController.Stub.asInterface(p1)
          isConnected = true
      }

      override fun onServiceDisconnected(p0: ComponentName?) {
          bookController = null
          isConnected = true
      }
  }

val intent = Intent(this,com.aidl.server.AIDLService)
      intent.also {
          bindService(it, serviceConnection, Context.BIND_AUTO_CREATE)
      }

AIDL的原理

AIDL是基于Binder机制进行通信，通过模版接口进行编译自动生成一个包含Server端的Binder对象(Stub)，和一个Client的代理对象(Proxy)：

public interface BookController extends android.os.IInterface
{

/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.czy.server.BookController
{
  private static final java.lang.String DESCRIPTOR = "com.czy.server.BookController";
  /** Construct the stub at attach it to the interface. */
  public Stub()
  {
    this.attachInterface(this, DESCRIPTOR);
  }
  /**
   * Cast an IBinder object into an com.czy.server.BookController interface,
   * generating a proxy if needed.
   */
  public static com.czy.server.BookController asInterface(android.os.IBinder obj)
  {
    if ((obj==null)) {
      return null;
    }
    android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
    if (((iin!=null)&&(iin instanceof com.czy.server.BookController))) {
      return ((com.czy.server.BookController)iin);
    }
    return new com.czy.server.BookController.Stub.Proxy(obj);
  }
  @Override public android.os.IBinder asBinder()
  {
    return this;
  }
  @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
  {
    java.lang.String descriptor = DESCRIPTOR;
    switch (code)
    {
      case INTERFACE_TRANSACTION:
      {
        reply.writeString(descriptor);
        return true;
      }
      case TRANSACTION_getBookList:
      {
        data.enforceInterface(descriptor);
        java.util.List _result = this.getBookList();
        reply.writeNoException();
        reply.writeTypedList(_result);
        return true;
      }
      case TRANSACTION_addBookInOut:
      {
        data.enforceInterface(descriptor);
        com.czy.server.Book _arg0;
        if ((0!=data.readInt())) {
          _arg0 = com.czy.server.Book.CREATOR.createFromParcel(data);
        }
        else {
          _arg0 = null;
        }
        this.addBookInOut(_arg0);
        reply.writeNoException();
        if ((_arg0!=null)) {
          reply.writeInt(1);
          _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        }
        else {
          reply.writeInt(0);
        }
        return true;
      }
      case TRANSACTION_addBookIn:
      {
        data.enforceInterface(descriptor);
        com.czy.server.Book _arg0;
        if ((0!=data.readInt())) {
          _arg0 = com.czy.server.Book.CREATOR.createFromParcel(data);
        }
        else {
          _arg0 = null;
        }
        this.addBookIn(_arg0);
        reply.writeNoException();
        return true;
      }
      case TRANSACTION_addBookOut:
      {
        data.enforceInterface(descriptor);
        com.czy.server.Book _arg0;
        _arg0 = new com.czy.server.Book();
        this.addBookOut(_arg0);
        reply.writeNoException();
        if ((_arg0!=null)) {
          reply.writeInt(1);
          _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        }
        else {
          reply.writeInt(0);
        }
        return true;
      }
      default:
      {
        return super.onTransact(code, data, reply, flags);
      }
    }
  }
  private static class Proxy implements com.czy.server.BookController
  {
    private android.os.IBinder mRemote;
    Proxy(android.os.IBinder remote)
    {
      mRemote = remote;
    }
    @Override public android.os.IBinder asBinder()
    {
      return mRemote;
    }
    public java.lang.String getInterfaceDescriptor()
    {
      return DESCRIPTOR;
    }
    @Override public java.util.List getBookList() throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      java.util.List _result;
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        boolean _status = mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          return getDefaultImpl().getBookList();
        }
        _reply.readException();
        _result = _reply.createTypedArrayList(com.czy.server.Book.CREATOR);
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
      return _result;
    }
    @Override public void addBookInOut(com.czy.server.Book book) throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        if ((book!=null)) {
          _data.writeInt(1);
          book.writeToParcel(_data, 0);
        }
        else {
          _data.writeInt(0);
        }
        boolean _status = mRemote.transact(Stub.TRANSACTION_addBookInOut, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          getDefaultImpl().addBookInOut(book);
          return;
        }
        _reply.readException();
        if ((0!=_reply.readInt())) {
          book.readFromParcel(_reply);
        }
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
    }
    @Override public void addBookIn(com.czy.server.Book book) throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        if ((book!=null)) {
          _data.writeInt(1);
          book.writeToParcel(_data, 0);
        }
        else {
          _data.writeInt(0);
        }
        boolean _status = mRemote.transact(Stub.TRANSACTION_addBookIn, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          getDefaultImpl().addBookIn(book);
          return;
        }
        _reply.readException();
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
    }
    @Override public void addBookOut(com.czy.server.Book book) throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        boolean _status = mRemote.transact(Stub.TRANSACTION_addBookOut, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          getDefaultImpl().addBookOut(book);
          return;
        }
        _reply.readException();
        if ((0!=_reply.readInt())) {
          book.readFromParcel(_reply);
        }
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
    }
    public static com.czy.server.BookController sDefaultImpl;
  }
  static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
  static final int TRANSACTION_addBookInOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
  static final int TRANSACTION_addBookIn = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
  static final int TRANSACTION_addBookOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
  public static boolean setDefaultImpl(com.czy.server.BookController impl) {
    // Only one user of this interface can use this function
    // at a time. This is a heuristic to detect if two different
    // users in the same process use this function.
    if (Stub.Proxy.sDefaultImpl != null) {
      throw new IllegalStateException("setDefaultImpl() called twice");
    }
    if (impl != null) {
      Stub.Proxy.sDefaultImpl = impl;
      return true;
    }
    return false;
  }
  public static com.czy.server.BookController getDefaultImpl() {
    return Stub.Proxy.sDefaultImpl;
  }
}

// 接口方法
public java.util.List getBookList() throws android.os.RemoteException;
public void addBookInOut(com.czy.server.Book book) throws android.os.RemoteException;
public void addBookIn(com.czy.server.Book book) throws android.os.RemoteException;
public void addBookOut(com.czy.server.Book book) throws android.os.RemoteException;
}

1. 首先定义Java接口

首先根据aidl文件，生成一个同名的Java接口，并继承IInterface

public interface BookController extends android.os.IInterface
{
// 接口方法
public java.util.List getBookList() throws android.os.RemoteException;
public void addBookInOut(com.czy.server.Book book) throws android.os.RemoteException;
public void addBookIn(com.czy.server.Book book) throws android.os.RemoteException;
public void addBookOut(com.czy.server.Book book) throws android.os.RemoteException;
}

2. Stub

生成一个代表Server端Binder的抽象类Stub，该Stub继承Binder类，并继承BookController接口，但Stub并没有实现BookController接口的方法而是留给Service实现。

/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.czy.server.BookController
{
  private static final java.lang.String DESCRIPTOR = "com.czy.server.BookController";
  /** Construct the stub at attach it to the interface. */
  public Stub()
  {
    this.attachInterface(this, DESCRIPTOR);
  }
  
  // 1. asInterface方法返回Proxy客户端的代理对象
  public static com.czy.server.BookController asInterface(android.os.IBinder obj)
  {
    if ((obj==null)) {
      return null;
    }
    android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
    if (((iin!=null)&&(iin instanceof com.czy.server.BookController))) {
      return ((com.czy.server.BookController)iin);
    }
    return new com.czy.server.BookController.Stub.Proxy(obj);
  }

  @Override public android.os.IBinder asBinder()
  {
    return this;
  }

   // 处理Client端的请求
  @Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
  {
    java.lang.String descriptor = DESCRIPTOR;
    switch (code)
    {
      case INTERFACE_TRANSACTION:
      {
        reply.writeString(descriptor);
        return true;
      }
      case TRANSACTION_getBookList:
      {
        data.enforceInterface(descriptor);
        // 调用实例的getBookList()方法
        java.util.List _result = this.getBookList();
        reply.writeNoException();
        // 把返回的数据回传给Client端
        reply.writeTypedList(_result);
        return true;
      }
      case TRANSACTION_addBookInOut:
      {
        data.enforceInterface(descriptor);
        com.czy.server.Book _arg0;
        if ((0!=data.readInt())) {
          _arg0 = com.czy.server.Book.CREATOR.createFromParcel(data);
        }
        else {
          _arg0 = null;
        }
        // 调用实例的addBookInOut方法
        this.addBookInOut(_arg0);
        reply.writeNoException();
        if ((_arg0!=null)) {
          reply.writeInt(1);
          _arg0.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
        }
        else {
          reply.writeInt(0);
        }
        return true;
      }
   
      default:
      {
        return super.onTransact(code, data, reply, flags);
      }
    }
  }

   // 逐渐+1的方式生存方法的对应的命令协议
  static final int TRANSACTION_getBookList = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
  static final int TRANSACTION_addBookInOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
  static final int TRANSACTION_addBookIn = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
  static final int TRANSACTION_addBookOut = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
  public static boolean setDefaultImpl(com.czy.server.BookController impl) {
    // Only one user of this interface can use this function
    // at a time. This is a heuristic to detect if two different
    // users in the same process use this function.
    if (Stub.Proxy.sDefaultImpl != null) {
      throw new IllegalStateException("setDefaultImpl() called twice");
    }
    if (impl != null) {
      Stub.Proxy.sDefaultImpl = impl;
      return true;
    }
    return false;
  }
  public static com.czy.server.BookController getDefaultImpl() {
    return Stub.Proxy.sDefaultImpl;
  }
}

Stub对象的asInterface方法返回一个客户端的Proxy对象。onTransact()方法根据命令协议执行不同的方法。

3. Proxy

客户端代理对象Proxy,其并没有继承Binder,而是继承了接口。

  private static class Proxy implements com.czy.server.BookController
  {
    private android.os.IBinder mRemote;
    Proxy(android.os.IBinder remote)
    {
      mRemote = remote;
    }
    @Override public android.os.IBinder asBinder()
    {
      return mRemote;
    }
    public java.lang.String getInterfaceDescriptor()
    {
      return DESCRIPTOR;
    }
    @Override public java.util.List getBookList() throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      java.util.List _result;
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        boolean _status = mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          return getDefaultImpl().getBookList();
        }
        _reply.readException();
        _result = _reply.createTypedArrayList(com.czy.server.Book.CREATOR);
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
      return _result;
    }
    @Override public void addBookInOut(com.czy.server.Book book) throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        if ((book!=null)) {
          _data.writeInt(1);
          book.writeToParcel(_data, 0);
        }
        else {
          _data.writeInt(0);
        }
        boolean _status = mRemote.transact(Stub.TRANSACTION_addBookInOut, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          getDefaultImpl().addBookInOut(book);
          return;
        }
        _reply.readException();
        if ((0!=_reply.readInt())) {
          book.readFromParcel(_reply);
        }
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
    }
    @Override public void addBookIn(com.czy.server.Book book) throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        if ((book!=null)) {
          _data.writeInt(1);
          book.writeToParcel(_data, 0);
        }
        else {
          _data.writeInt(0);
        }
        boolean _status = mRemote.transact(Stub.TRANSACTION_addBookIn, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          getDefaultImpl().addBookIn(book);
          return;
        }
        _reply.readException();
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
    }
    @Override public void addBookOut(com.czy.server.Book book) throws android.os.RemoteException
    {
      android.os.Parcel _data = android.os.Parcel.obtain();
      android.os.Parcel _reply = android.os.Parcel.obtain();
      try {
        _data.writeInterfaceToken(DESCRIPTOR);
        boolean _status = mRemote.transact(Stub.TRANSACTION_addBookOut, _data, _reply, 0);
        if (!_status && getDefaultImpl() != null) {
          getDefaultImpl().addBookOut(book);
          return;
        }
        _reply.readException();
        if ((0!=_reply.readInt())) {
          book.readFromParcel(_reply);
        }
      }
      finally {
        _reply.recycle();
        _data.recycle();
      }
    }
    public static com.czy.server.BookController sDefaultImpl;
  }

你可能感兴趣的:(Binder 应用层-AIDL原理)

  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • git - Webhook让部署自动化 大猪大猪
    我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
  • ARM驱动学习之基础小知识 JT灬新一 ARM嵌入式arm开发学习
    ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • ES聚合分析原理与代码实例讲解 光剑书架上的书 大厂Offer收割机面试题简历程序员读书硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    ES聚合分析原理与代码实例讲解1.背景介绍1.1问题的由来在大规模数据分析场景中，特别是在使用Elasticsearch（ES）进行数据存储和检索时，聚合分析成为了一个至关重要的功能。聚合分析允许用户对数据集进行细分和分组，以便深入探索数据的结构和模式。这在诸如实时监控、日志分析、业务洞察等领域具有广泛的应用。1.2研究现状目前，ES聚合分析已经成为现代大数据平台的核心组件之一。它支持多种类型的聚
  • 2022-08-28 蔚蓝一片晴
    初三暑假培训收获点滴从8月25至8月27日三天两晚的培训结束了，回到家中，该静下心来整理一下触动心灵的收获，成为成长的积淀。1.在优秀团队中快速成长与提升，做一名反思成长型教师一名专业型教师的教学指导包括了教学原理知识、案例知识、策略知识。面对教学中的遇到的有趣的情形、问题会去研究其理，寻找更好的教法学法对策。从新手到成熟型教师，再走向专业型教师，需要的是觉醒与反思，多进行案例研究，从案例中观察、
  • STM32中的计时与延时 lupinjia STM32stm32单片机
    前言在裸机开发中，延时作为一种规定循环周期的方式经常被使用，其中尤以HAL库官方提供的HAL_Delay为甚。刚入门的小白可能会觉得既然有官方提供的延时函数，而且精度也还挺好，为什么不用呢？实际上HAL_Delay中有不少坑，而这些也只是HAL库中无数坑的其中一些。想从坑里跳出来还是得加强外设原理的学习和理解，切不可只依赖HAL库。除了延时之外，我们在开发中有时也会想要确定某段程序的耗时，这就需要
  • 第1步win10宿主机与虚拟机通过NAT共享上网互通 学习3人组 大数据大数据
    VM的CentOS采用NAT共用宿主机网卡宿主机器无法连接到虚拟CentOS要实现宿主机与虚拟机通信，原理就是给宿主机的网卡配置一个与虚拟机网关相同网段的IP地址，实现可以互通。1、查看虚拟机的IP地址2、编辑虚拟机的虚拟网络的NAT和DHCP的配置，设置虚拟机的网卡选择NAT共享模式3、宿主机的IP配置，确保vnet8的IPV4属性与虚拟机在同一网段4、ping测试连通性[root@localh
  • 5分钟说透AppStore审核原理，让你拥有上架新思路！ Q仔本人噢
    在AppStore上架是越来越难了!相信非常多公司的技术人员都为此困扰，然而外包团队水平又层次不齐，容易遇坑，实在是内忧外患。是什么原因导致审核机制频繁调整？又是什么原因使得审核变得越发严格？那么接下来听小Q分解，马上给各位带来解答!首先看一下近一年的上下架的情况：近一年上架情况近一年下架情况通过数据我们发现越是马甲包产量权重高的分类里被下架的app数量越多，苹果此举可谓是上有政策，下有对策。通过
  • 2019-03-24 李飞720
    姓名：李飞企业名称：临沂鑫道食品有限公司组别373期利他1组日精进打卡第338天】【知~学习】1、阿米巴经营一段2、活用人才1段3、活法、一段【行~实践】一、修身：读书、抽烟减量、俯卧撑个跑步3公里二、齐家、劝说老爸与姑姑和好三、建功、业务洽谈【经典名句分享】1、依据原理原则追求事物的本质，以“作为人，何谓正确”进行判断2、经营者必须为员工物质和精神两方面的幸福殚精竭虑，倾尽全力，必须超脱私心，让
  • 计算机木马详细编写思路 小熊同学哦 php开发语言木马木马思路
    导语：计算机木马（ComputerTrojan）是一种恶意软件，通过欺骗用户从而获取系统控制权限，给黑客打开系统后门的一种手段。虽然木马的存在给用户和系统带来严重的安全风险，但是了解它的工作原理与编写思路，对于我们提高防范意识、构建更健壮的网络安全体系具有重要意义。本篇博客将深入剖析计算机木马的详细编写思路，以及如何复杂化挑战，以期提高读者对计算机木马的认识和对抗能力。计算机木马的基本原理计算机木
  • 在RabbitMQ中四种常见的消息路由模式 Xwzzz_ rabbitmq分布式
    1.Fanout模式Fanout模式的交换机是扇出交换机（FanoutExchange），它会将消息广播给所有绑定到它的队列，而不考虑消息的内容或路由键。工作原理：生产者发送消息到FanoutExchange。FanoutExchange会将消息广播给所有绑定到它的队列，所有绑定的队列都会收到这条消息。消费者监听绑定的队列，处理收到的消息。特点：没有路由键：消息不需要路由键，所有绑定的队列都会接收
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • WebMagic：强大的Java爬虫框架解析与实战 Aaron_945 Javajava爬虫开发语言
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
  • 《 C++ 修炼全景指南：十 》自平衡的艺术：深入了解 AVL 树的核心原理与实现 Lenyiin C++修炼全景指南技术指南c++数据结构stl
    摘要本文深入探讨了AVL树（自平衡二叉搜索树）的概念、特点以及实现细节。我们首先介绍了AVL树的基本原理，并详细分析了其四种旋转操作，包括左旋、右旋、左右双旋和右左双旋，阐述了它们在保持树平衡中的重要作用。接着，本文从头到尾详细描述了AVL树的插入、删除和查找操作，配合完整的代码实现和详尽的注释，使读者能够全面理解这些操作的执行过程。此外，我们还提供了AVL树的遍历方法，包括中序、前序和后序遍历，
  • 计算机网络八股总结 Petrichorzncu 八股总结计算机网络笔记
    这里写目录标题网络模型划分（五层和七层）及每一层的功能五层网络模型七层网络模型（OSI模型）==三次握手和四次挥手具体过程及原因==三次握手四次挥手TCP/IP协议组成==UDP协议与TCP/IP协议的区别==Http协议相关知识网络地址，子网掩码等相关计算网络模型划分（五层和七层）及每一层的功能五层网络模型应用层：负责处理网络应用程序，如电子邮件、文件传输和网页浏览。主要协议包括HTTP、FTP
  • 非对称加密算法原理与应用2——RSA私钥加密文件 私语茶馆 云部署与开发架构及产品灵感记录RSA2048私钥加密
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
  • 为什么学生不喜欢上学 虾虾说
    图片发自App《为什么学生不喜欢上学》作者是丹尼尔·威林厄姆。本书从认知心理学角度，结合大量实证案例，阐释了大脑工作的基本原理，回答了关于学习过程的一系列问题。为什么学生不喜欢上学？——大脑工作的基本原理思考是缓慢的、费力的、不可靠的。思考有三个要素，环境、工作记忆和长期记忆。环境是信息来源；长期记忆是知识、经验的巨型仓库，随时可以调取；工作记忆是中央处理器，是加工信息素材的中央厨房，也是思考过程
  • 补充元象二面 Redstone Monstrosity 前端面试
    1.请尽可能详细地说明，防抖和节流的区别，应用场景？你的回答中不要写出示例代码。防抖（Debounce）和节流（Throttle）是两种常用的前端性能优化技术，它们的主要区别在于如何处理高频事件的触发。以下是防抖和节流的区别和应用场景的详细说明：防抖和节流的定义防抖：在一段时间内，多次执行变为只执行最后一次。防抖的原理是，当事件被触发后，设置一个延迟定时器。如果在这个延迟时间内事件再次被触发，则重
  • 《 C++ 修炼全景指南：四 》揭秘 C++ List 容器背后的实现原理，带你构建自己的双向链表 Lenyiin 技术指南C++修炼全景指南c++list链表stl
    本篇博客，我们将详细讲解如何从头实现一个功能齐全且强大的C++List容器，并深入到各个细节。这篇博客将包括每一步的代码实现、解释以及扩展功能的探讨，目标是让初学者也能轻松理解。一、简介1.1、背景介绍在C++中，std::list是一个基于双向链表的容器，允许高效的插入和删除操作，适用于频繁插入和删除操作的场景。与动态数组不同，list允许常数时间内的插入和删除操作，支持双向遍历。这篇文章将详细
  • AI大模型的架构演进与最新发展 季风泯灭的季节 AI大模型应用技术二人工智能架构
    随着深度学习的发展，AI大模型（LargeLanguageModels,LLMs）在自然语言处理、计算机视觉等领域取得了革命性的进展。本文将详细探讨AI大模型的架构演进，包括从Transformer的提出到GPT、BERT、T5等模型的历史演变，并探讨这些模型的技术细节及其在现代人工智能中的核心作用。一、基础模型介绍：Transformer的核心原理Transformer架构的背景在Transfo
  • [实践应用] 深度学习之优化器 YuanDaima2048 深度学习工具使用pytorch深度学习人工智能机器学习python优化器
    文章总览：YuanDaiMa2048博客文章总览深度学习之优化器1.随机梯度下降（SGD）2.动量优化（Momentum）3.自适应梯度（Adagrad）4.自适应矩估计（Adam）5.RMSprop总结其他介绍在深度学习中，优化器用于更新模型的参数，以最小化损失函数。常见的优化函数有很多种，下面是几种主流的优化器及其特点、原理和PyTorch实现：1.随机梯度下降（SGD）原理:随机梯度下降通过
  • 【高阶数据结构】并查集 椿融雪 数据结构与算法数据结构并查集
    文章目录一、并查集原理二、并查集实现三、并查集应用一、并查集原理在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，
  • 《HTML 与 CSS—— 响应式设计》 陈在天box htmlcss前端
    一、引言在当今数字化时代，人们使用各种不同的设备访问互联网，包括智能手机、平板电脑、笔记本电脑和台式机等。为了确保网站在不同设备上都能提供良好的用户体验，响应式设计成为了网页开发的关键。HTML和CSS作为网页开发的基础技术，在实现响应式设计方面发挥着重要作用。本文将深入探讨HTML与CSS中的响应式设计原理、方法和最佳实践。二、响应式设计的概念与重要性（一）概念响应式设计是一种网页设计方法，旨在
  • KVM虚拟机源代码分析【转】 xidianjiapei001 #虚拟化技术
    1.KVM结构及工作原理1.1KVM结构KVM基本结构有两部分组成。一个是KVMDriver，已经成为Linux内核的一个模块。负责虚拟机的创建，虚拟内存的分配，虚拟CPU寄存器的读写以及虚拟CPU的运行等。另外一个是稍微修改过的Qemu，用于模拟PC硬件的用户空间组件，提供I/O设备模型以及访问外设的途径。KVM基本结构如图1所示。其中KVM加入到标准的Linux内核中，被组织成Linux中标准
  • 嵌入式单片机中数码管基本实现方法 嵌入式开发星球 单片机项目实战操作之优秀单片机
    1.点亮数码管本节课利用已经学习的LED知识去控制一个8位数码管。本节的原理比较简单。不需要多少时间讲。更多时间是跟大家一起编码调试，从中学习一些编码思路和学习方法。1.1.什么是数码管数码管是什么？下图就是一个数码管从硬件上个看，其实就是8个LED组合在一起。8个LED应该有16个引脚，但是数码管上只有10个引脚。为什么呢？请看下图：1个LED有两个引脚，要控制LED，1个引脚接控制信号，另外一
  • 360前端星计划-动画可以这么玩 马小蜗
    动画的基本原理定时器改变对象的属性根据新的属性重新渲染动画functionupdate(context){//更新属性}constticker=newTicker();ticker.tick(update,context);动画的种类1、JavaScript动画操作DOMCanvas2、CSS动画transitionanimation3、SVG动画SMILJS动画的优缺点优点：灵活度、可控性、性能
  • 俞军关于企业本质的读书思考 小廖BOY
    本文内容来自于俞军老师的聊天记录关于企业本质的一点思考总体上，企业的本质，只在于两点：1.发现市场获利机会。2.生产效率高于市场。一、发现市场获利机会发现市场获利机会的路径有三种：洞察，其实是利用信息不对称获利。你知道哪里能买到便宜生产要素，你知道哪些用户更想要什么，你精通一种有用的新技术新方法新渠道，你知道什么约束条件将会变化，而别人不知道，这里就都有市场获利机会。试错，其实是因为信息不完全原理
  • 关于旗正规则引擎规则中的上传和下载问题 何必如此 文件下载压缩jsp文件上传
    文件的上传下载都是数据流的输入输出，大致流程都是一样的。 一、文件打包下载 1.文件写入压缩包 string mainPath="D:\upload\";     下载路径 string tmpfileName=jar.zip;        &n
  • 【Spark九十九】Spark Streaming的batch interval时间内的数据流转源码分析 bit1129 Stream
      以如下代码为例（SocketInputDStream）： Spark Streaming从Socket读取数据的代码是在SocketReceiver的receive方法中，撇开异常情况不谈(Receiver有重连机制，restart方法，默认情况下在Receiver挂了之后，间隔两秒钟重新建立Socket连接)，读取到的数据通过调用store(textRead)方法进行存储。数据
  • spark master web ui 端口8080被占用解决方法 daizj 8080端口占用sparkmaster web ui
    spark master web ui 默认端口为8080，当系统有其它程序也在使用该接口时，启动master时也不会报错，spark自己会改用其它端口，自动端口号加1，但为了可以控制到指定的端口，我们可以自行设置，修改方法：   1、cd SPARK_HOME/sbin   2、vi start-master.sh     3、定位到下面部分
  • oracle_执行计划_谓词信息和数据获取 周凡杨 oracle执行计划
      oracle_执行计划_谓词信息和数据获取(上) 一：简要说明 在查看执行计划的信息中，经常会看到两个谓词filter和access，它们的区别是什么，理解了这两个词对我们解读Oracle的执行计划信息会有所帮助。 简单说，执行计划如果显示是access，就表示这个谓词条件的值将会影响数据的访问路径（表还是索引），而filter表示谓词条件的值并不会影响数据访问路径，只起到
  • spring中datasource配置 g21121 dataSource
    datasource配置有很多种，我介绍的一种是采用c3p0的，它的百科地址是： http://baike.baidu.com/view/920062.htm   <!-- spring加载资源文件 --> <bean name="propertiesConfig" class="org.springframework.b
  • web报表工具FineReport使用中遇到的常见报错及解决办法（三） 老A不折腾 finereportFAQ报表软件
    这里写点抛砖引玉，希望大家能把自己整理的问题及解决方法晾出来，Mark一下，利人利己。   出现问题先搜一下文档上有没有，再看看度娘有没有，再看看论坛有没有。有报错要看日志。下面简单罗列下常见的问题，大多文档上都有提到的。 1、repeated column width is largerthan paper width： 这个看这段话应该是很好理解的。比如做的模板页面宽度只能放
  • mysql 用户管理 墙头上一根草 linuxmysqluser
    1.新建用户 //登录MYSQL@>mysql -u root -p@>密码//创建用户mysql> insert into mysql.user(Host,User,Password) values(‘localhost’,'jeecn’,password(‘jeecn’));//刷新系统权限表mysql>flush privileges;这样就创建了一个名为：
  • 关于使用Spring导致c3p0数据库死锁问题 aijuans springSpring 入门Spring 实例Spring3Spring 教程
    这个问题我实在是为整个 springsource 的员工蒙羞 如果大家使用 spring 控制事务，使用 Open Session In View 模式， com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.
  • 百度词库联想 annan211 百度
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>RunJS</title&g
  • int数据与byte之间的相互转换实现代码 百合不是茶 位移int转bytebyte转int基本数据类型的实现
    在BMP文件和文件压缩时需要用到的int与byte转换,现将理解的贴出来;   主要是要理解;位移等概念 http://baihe747.iteye.com/blog/2078029   int转byte;   byte转int;   /** * 字节转成int,int转成字节 * @author Administrator *
  • 简单模拟实现数据库连接池 bijian1013 javathreadjava多线程简单模拟实现数据库连接池
    简单模拟实现数据库连接池 实例1： package com.bijian.thread; public class DB { //private static final int MAX_COUNT = 10; private static final DB instance = new DB(); private int count = 0; private i
  • 一种基于Weblogic容器的鉴权设计 bijian1013 javaweblogic
            服务器对请求的鉴权可以在请求头中加Authorization之类的key，将用户名、密码保存到此key对应的value中，当然对于用户名、密码这种高机密的信息，应该对其进行加砂加密等，最简单的方法如下： String vuser_id = "weblogic"; String vuse
  • 【RPC框架Hessian二】Hessian 对象序列化和反序列化 bit1129 hessian
     任何一个对象从一个JVM传输到另一个JVM，都要经过序列化为二进制数据(或者字符串等其他格式，比如JSON)，然后在反序列化为Java对象，这最后都是通过二进制的数据在不同的JVM之间传输(一般是通过Socket和二进制的数据传输)，本文定义一个比较符合工作中。   1. 定义三个POJO    Person类 package com.tom.hes
  • 【Hadoop十四】Hadoop提供的脚本的功能 bit1129 hadoop
    1. hadoop-daemon.sh 1.1 启动HDFS ./hadoop-daemon.sh start namenode ./hadoop-daemon.sh start datanode  通过这种逐步启动的方式，比start-all.sh方式少了一个SecondaryNameNode进程，这不影响Hadoop的使用，其实在 Hadoop2.0中，SecondaryNa
  • 中国互联网走在“灰度”上 ronin47 管理 灰度
    中国互联网走在“灰度”上（转） 文/孕峰   第一次听说灰度这个词，是任正非说新型管理者所需要的素质。第二次听说是来自马化腾。似乎其他人包括马云也用不同的语言说过类似的意思。   灰度这个词所包含的意义和视野是广远的。要理解这个词，可能同样要用“灰度”的心态。灰度的反面，是规规矩矩，清清楚楚，泾渭分明，严谨条理，是决不妥协，不转弯，认死理。黑白分明不是灰度，像彩虹那样
  • java-51-输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 bylijinnan java
    public class PrintMatrixClockwisely { /** * Q51.输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。 例如：如果输入如下矩阵： 1 2 3 4 5 6 7 8 9
  • mongoDB 用户管理 开窍的石头 mongoDB用户管理
      1:添加用户    第一次设置用户需要进入admin数据库下设置超级用户（use admin）      db.addUsr({user:'useName',pwd:'111111',roles:[readWrite,dbAdmin]});    第一个参数用户的名字    第二个参数
  • [游戏与生活]玩暗黑破坏神3的一些问题 comsci 生活
        暗黑破坏神3是有史以来最让人激动的游戏。。。。但是有几个问题需要我们注意      玩这个游戏的时间，每天不要超过一个小时，且每次玩游戏最好在白天      结束游戏之后，最好在太阳下面来晒一下身上的暗黑气息，让自己恢复人的生气   &nb
  • java 二维数组如何存入数据库 cuiyadll java
    using System; using System.Linq; using System.Text; using System.Windows.Forms; using System.Xml; using System.Xml.Serialization; using System.IO; namespace WindowsFormsApplication1 {
  • 本地事务和全局事务Local Transaction and Global Transaction(JTA) darrenzhu javaspringlocalglobaltransaction
    Configuring Spring and JTA without full Java EE http://spring.io/blog/2011/08/15/configuring-spring-and-jta-without-full-java-ee/ Spring doc -Transaction Management http://docs.spring.io/spri
  • Linux命令之alias - 设置命令的别名，让 Linux 命令更简练 dcj3sjt126com linuxalias
    用途说明 设置命令的别名。在linux系统中如果命令太长又不符合用户的习惯，那么我们可以为它指定一个别名。虽然可以为命令建立“链接”解决长文件名的问 题，但对于带命令行参数的命令，链接就无能为力了。而指定别名则可以解决此类所有问题【1】。常用别名来简化ssh登录【见示例三】，使长命令变短，使常 用的长命令行变短，强制执行命令时询问等。   常用参数 格式：alias 格式：ali
  • yii2 restful web服务[格式响应] dcj3sjt126com PHPyii2
    响应格式 当处理一个 RESTful API 请求时， 一个应用程序通常需要如下步骤 来处理响应格式： 确定可能影响响应格式的各种因素， 例如媒介类型， 语言， 版本， 等等。 这个过程也被称为 content negotiation。 资源对象转换为数组， 如在 Resources 部分中所描述的。 通过 [[yii\rest\Serializer]]
  • MongoDB索引调优（2）——[十] eksliang mongodbMongoDB索引优化
    转载请出自出处：http://eksliang.iteye.com/blog/2178555 一、概述       上一篇文档中也说明了，MongoDB的索引几乎与关系型数据库的索引一模一样，优化关系型数据库的技巧通用适合MongoDB，所有这里只讲MongoDB需要注意的地方 二、索引内嵌文档     可以在嵌套文档的键上建立索引，方式与正常
  • 当滑动到顶部和底部时，实现Item的分离效果的ListView gundumw100 android
    拉动ListView，Item之间的间距会变大，释放后恢复原样； package cn.tangdada.tangbang.widget; import android.annotation.TargetApi; import android.content.Context; import android.content.res.TypedArray; import andr
  • 程序员用HTML5制作的爱心树表白动画 ini JavaScriptjqueryWebhtml5css
    体验效果：http://keleyi.com/keleyi/phtml/html5/31.htmHTML代码如下： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"><head><meta charset="UTF-8" > <ti
  • 预装windows 8 系统GPT模式的ThinkPad T440改装64位 windows 7旗舰版 kakajw ThinkPad预装改装windows 7windows 8
      该教程具有普遍参考性，特别适用于联想的机器，其他品牌机器的处理过程也大同小异。 该教程是个人多次尝试和总结的结果，实用性强，推荐给需要的人！   缘由 小弟最近入手笔记本ThinkPad T440，但是特别不能习惯笔记本出厂预装的Windows 8系统，而且厂商自作聪明地预装了一堆没用的应用软件，消耗不少的系统资源（本本的内存为4G，系统启动完成时，物理内存占用比
  • Nginx学习笔记 mcj8089 nginx
    一、安装nginx             1、在nginx官方网站下载一个包，下载地址是：  http://nginx.org/download/nginx-1.4.2.tar.gz      2、WinSCP(ftp上传工
  • mongodb 聚合查询每天论坛链接点击次数 qiaolevip 每天进步一点点学习永无止境mongodb纵观千象
    /* 18 */ { "_id" : ObjectId("5596414cbe4d73a327e50274"), "msgType" : "text", "sendTime" : ISODate("2015-07-03T08:01:16.000Z"
  • java术语（PO/POJO/VO/BO/DAO/DTO） Luob. DAOPOJODTOpoVO BO
    PO(persistant object) 持久对象 在o/r 映射的时候出现的概念,如果没有o/r映射,就没有这个概念存在了.通常对应数据模型(数据库),本身还有部分业务逻辑的处理.可以看成是与数据库中的表相映射的java对象.最简单的PO就是对应数据库中某个表中的一条记录,多个记录可以用PO的集合.PO中应该不包含任何对数据库的操作. VO(value object) 值对象 通
  • 算法复杂度 Wuaner Algorithm
    Time Complexity & Big-O： http://stackoverflow.com/questions/487258/plain-english-explanation-of-big-o http://bigocheatsheet.com/ http://www.sitepoint.com/time-complexity-algorithms/
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他