程序员经验分享-hwhale

Android 连接有时会被拒绝（并非所有时候）

2024-05-09

我编写了一个 WiFi-Direct 代码连接并在它们之间创建了一个连接，然后我创建了一个ServerSocket在第一面和一个Socket在客户端并开始在它们之间发送数据，第一次启动应用程序时它工作成功，但是当我关闭应用程序并再次启动它时，它给了我一个异常，显示“连接被拒绝 ECONNREFUSED” 这是我在服务器端的代码：

package com.example.serverwifidirect;
import java.io.InputStream;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import android.annotation.SuppressLint;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.NetworkInfo;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager.ActionListener;
import android.net.wifi.p2p.WifiP2pManager.Channel;
import android.net.wifi.p2p.WifiP2pManager.PeerListListener;
import android.os.Bundle;
import android.util.Log;
import android.widget.Toast;
public class BroadcastServer extends BroadcastReceiver
{
    @SuppressLint("NewApi")
    private WifiP2pManager mManager;
    private Channel mChannel;
    private Server mActivity;
    static boolean temp=false;
    Socket client=null;
    static boolean isRunning = false;
    ServerSocket serverSocket = null;
    InetSocketAddress inet;
    private void closeConnections()
    {
        try
        {
            if(client!=null || serverSocket!=null)
            {
                if(client!=null)
                {
                    if(client.isInputShutdown()|| client.isOutputShutdown())
                    {
                        log("x1");
                        client.close();
                    }
                    if(client.isConnected())
                    {
                        log("x2");
                        client.close();
                        log("x2.1");
                        //client.bind(null);
                        log("x2.2");
                    }
                    if(client.isBound())
                    {
                        log("x3");
                        client.close();
                    }
                    client=null;
                }
            }
        }
        catch(Exception e)
        {
            log("Error :'(");
            e.printStackTrace();
        }
    }
    @SuppressLint("NewApi")
    public BroadcastServer(WifiP2pManager manager, Channel channel, Server activity) 
    {
        super();
        this.mManager = manager;
        this.mChannel = channel;
        this.mActivity = activity;
        try
        {
            serverSocket = new ServerSocket(8870);
            serverSocket.setReuseAddress(true);
        }
        catch(Exception e)
        {
        }
    }
    @SuppressLint("NewApi")
    @Override
    public void onReceive(Context context, Intent intent)
    {
        String action = intent.getAction();
        if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action))
        {
            int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
            if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED)
            {}
            else
            {}
        }
        else if(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action))
        {
            mManager.requestPeers(mChannel, new PeerListListener()
            {
                @Override
                public void onPeersAvailable(WifiP2pDeviceList list)
                {
                }
            });
        } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action))
        {
            Bundle b = intent.getExtras();
            NetworkInfo info = (NetworkInfo)b.get(WifiP2pManager.EXTRA_NETWORK_INFO);
            if(info.isFailover())
            {
                temp=false;
            }
            else if(info.isConnected())
            {
                temp=true;
                log("c1");
                new Thread(new Runnable(){
                    public void run()
                    {
                        try
                        {
                            client =serverSocket.accept();
                            InputStream input=null;
                            input = client.getInputStream();
                            log("q3");
                            while(BroadcastServer.temp)
                            {
                                final int n = input.read();
                                if(n==100)
                                {
                                    closeConnections();
                                    mManager.cancelConnect(mChannel, new ActionListener() {

                                        @Override
                                        public void onSuccess() 
                                        {
                                            log("done");
                                            mManager.removeGroup(mChannel, new ActionListener() 
                                            {
                                                @Override
                                                public void onSuccess() 
                                                {
                                                    log("group removed");
                                                }

                                                @Override
                                                public void onFailure(int reason) 
                                                {
                                                    log("fail!!!!!");
                                                }
                                            });
                                        }
                                        @Override
                                        public void onFailure(int reason) {
                                        log("fail");
                                            mManager.removeGroup(mChannel, new ActionListener() 
                                            {
                                                @Override
                                                public void onSuccess() 
                                                {
                                                    log("group removed");
                                                }

                                                @Override
                                                public void onFailure(int reason) 
                                                {
                                                    log("fail!!!!!");
                                                }
                                            });
                                        }
                                    });
                                }
                                log("q4");
                                if(n==-1)
                                {
                                    log("n = -1");
                                    break;
                                }
                                log("n= "+n);
                                mActivity.runOnUiThread(new Runnable()
                                {
                                    public void run()
                                    {
                                        Toast.makeText(mActivity.getBaseContext(), "--"+n, Toast.LENGTH_SHORT).show();  
                                    }
                                });

                            }
                            log("After loop");
                        }
                        catch(Exception e)
                        {
                        }
                    }
                });
                mActivity.runOnUiThread(new Runnable(){
                        public void run()
                        {
                            //Toast.makeText(mActivity, "Connected to WiFi-Direct!", Toast.LENGTH_SHORT).show();                                
                        }
                    });

                log("c2");
            }
            else if(info.isConnectedOrConnecting())
            {
                temp=false;
            }
            else if(!info.isConnected())
            {

                temp=false;
                try
                {

                    if(client!=null || serverSocket!=null)
                    {
                        if(client!=null)
                        {
                            if(client.isInputShutdown()|| client.isOutputShutdown())
                            {
                                log("x1");
                                client.close();
                            }
                            if(client.isConnected())
                            {
                                log("x2");
                                client.close();
                                log("x2.1");
                                //client.bind(null);
                                log("x2.2");
                            }
                            if(client.isBound())
                            {
                                log("x3");
                                client.close();
                            }
                            client=null;
                        }
                    }
                }
                catch(Exception e)
                {
                    log("Error :'(");
                    e.printStackTrace();
                }
                mManager.clearLocalServices(mChannel, new ActionListener() 
                {
                    @Override
                    public void onSuccess() 
                    {
                        log("success");
                    }
                    @Override
                    public void onFailure(int reason) 
                    {   
                    }
                });
            }
        }
        else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action))
        {
            log("Device change Action!");
        }
    }
    public static void log(String shusmu)
    {
        Log.d("status", shusmu);
    }
}

这段代码在Server端，下面的代码在Client端：

package com.example.wifidirect;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.NetworkInfo;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pDeviceList;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager.ActionListener;
import android.net.wifi.p2p.WifiP2pManager.Channel;
import android.net.wifi.p2p.WifiP2pManager.PeerListListener;
import android.os.Bundle;
import android.util.Log;
import android.widget.Button;

@SuppressLint("NewApi")
public class WiFiDirectBroadcastReceiver extends BroadcastReceiver 
{
    static WifiP2pDevice connectedDevice = null;
    boolean found=false;
    boolean connected = false;
    private WifiP2pManager mManager;
    private Channel mChannel;
    Button find = null;
    Activity mActivity = null;
    @SuppressLint("NewApi")
    public WiFiDirectBroadcastReceiver(WifiP2pManager manager, Channel channel, WifiDirect activity) 
    {
        super();

        this.mManager = manager;
        this.mChannel = channel;
        mActivity = activity;
        find = (Button)mActivity.findViewById(R.id.discover);
    }
    @SuppressLint("NewApi")
    @Override
    public void onReceive(Context context, Intent intent) 
    {
        String action = intent.getAction();
        if (WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION.equals(action)) 
        {
            int state = intent.getIntExtra(WifiP2pManager.EXTRA_WIFI_STATE, -1);
            if (state == WifiP2pManager.WIFI_P2P_STATE_ENABLED) 
            {
                // Wifi Direct is enabled
            } else 
            {
                // Wi-Fi Direct is not enabled
            }
        }
        else if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) 
        {
            mManager.requestPeers(mChannel, new PeerListListener() 
            {
                @Override
                public void onPeersAvailable(WifiP2pDeviceList list) 
                {
                    WifiP2pDevice d = null;
                    if(!found)
                    {
                        Log.d("status", "2");
                        Collection<WifiP2pDevice>li = list.getDeviceList();
                        ArrayList<WifiP2pDevice> arrayList = new ArrayList<WifiP2pDevice>();
                        Iterator<WifiP2pDevice>peers = li.iterator();
                        while(peers.hasNext())
                        {
                            WifiP2pDevice device = peers.next();
                            arrayList.add(device);
                        }

                        for(int i=0;i<arrayList.size();i++)
                        {
                            log("xxx");
                            log(arrayList.get(i).deviceName);
                            if(arrayList.get(i).deviceName.equalsIgnoreCase("Android_144b"))
                            { 
                                d = arrayList.get(i);
                                arrayList.clear();
                                found = true;
                                break;
                            }
                        }
                    }
                    if(d!=null)
                    {

                            WifiP2pConfig config = new WifiP2pConfig();
                            config.deviceAddress = d.deviceAddress;
                            if(!connected)
                            {
                                mManager.connect(mChannel, config, new ActionListener() 
                                {
                                    @Override
                                    public void onSuccess() 
                                    {
                                        connected = true;
                                    }
                                    @Override
                                    public void onFailure(int reason) 
                                    {
                                        connected=false;
                                        mManager.cancelConnect(mChannel, new ActionListener() 
                                        {
                                            @Override
                                            public void onSuccess() 
                                            {
                                                Log.d("status", "success on cancelConnect()");
                                            }
                                            @Override
                                            public void onFailure(int reason) 
                                            {   
                                                Log.d("status", "Fail on cancelConnect()");
                                            }
                                        });
                                    }
                                });
                            }
                        }
                    }
            });
        } else if (WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION.equals(action)) 
        {
            Bundle b = intent.getExtras();
            NetworkInfo info = (NetworkInfo)b.get(WifiP2pManager.EXTRA_NETWORK_INFO);
            if(info.isFailover())
            {
                connected=false;
                Log.d("status", "connection failure!");
            }
            else if(info.isConnected())
            {
                connected=true;
                find.setEnabled(false);
                Log.d("status", "connection is Connected!");
            }
            else if(info.isConnectedOrConnecting())
            {
                connected=false;
                log("Connecting !!!");
            }
            else if(!info.isConnected())
            {
                if(connected)
                {
                    //closeConnections();
                    connected=false;
                }
                find.setEnabled(true);
                mManager.removeGroup(mChannel, new ActionListener() 
                {
                    @Override
                    public void onSuccess() 
                    {   
                        log("Success disconnect");
                    }
                    @Override
                    public void onFailure(int arg0) 
                    {   
                        log("Fail disconnect");
                    }
                });
            }
        }
        else if (WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION.equals(action)) 
        {}
    }
    public static void log(String shusmu)
    {
        Log.d("status", shusmu);
    }

}

这就是班级Connection

package com.example.wifidirect;

import java.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

import android.annotation.SuppressLint;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager.ActionListener;
import android.net.wifi.p2p.WifiP2pManager.Channel;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

@SuppressLint("NewApi")
public class Connection 
{
    boolean found = false;
    OutputStream out=null;
    Socket socket = null;
    boolean connected =false;
    WiFiDirectBroadcastReceiver mReceiver=null;
    WifiDirect instance=null;
    @SuppressLint("NewApi")
    Channel mChannel=null;
    WifiP2pManager mManager=null;
    public void sendMessage(int msg)
    {
        try
        {
            out.write(msg);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    public Connection(WiFiDirectBroadcastReceiver mReceiver,WifiDirect instance,Channel mChannel,WifiP2pManager mManager) throws UnknownHostException, IOException
    {
        this.instance=instance;
        this.mReceiver=mReceiver;
        this.mChannel=mChannel;
        this.mManager= mManager;
        socket = null;
        Button send = (Button)instance.findViewById(R.id.send);
        send.setOnClickListener(new OnClickListener() 
        {   
            @Override
            public void onClick(View arg0) 
            {
                try
                {
                    log("z1");
                    if(socket==null)
                    {
                        log("z2");
                        Thread t = new Thread(new Runnable()
                        {
                            public void run()
                            {
                                try
                                {
                                    log("z3");
                                    socket= new Socket("192.168.49.1",8870);
                                    socket.setReuseAddress(true);
                                    log("z4");
                                    out = socket.getOutputStream();
                                    connected = true;
                                }
                                catch(Exception e)
                                {
                                    e.printStackTrace();
                                }
                            }   
                        });
                        t.setDaemon(false);
                        t.start();
                    }

                    new Thread(new Runnable()
                    {
                        public void run()
                        {
                            log("trying to Send !");
                            while(!connected);
                            sendMessage(10);
                            log(" Data sent !");
                        }
                    }).start();


                }
                catch(Exception e)
                {
                    log("exception_1");
                    e.printStackTrace();
                    log("exception_2");
                    log(e.getMessage());
                }
            }
        });
    }
    public void closeConnections()
    {
        try
        {
            if(out!=null)
            {
                out.close();
                out=null;
            }
            if(socket!=null)
            {
                socket.shutdownInput();
                socket.shutdownOutput();
                if(socket.isInputShutdown()|| socket.isOutputShutdown())
                {   
                    socket.close();
                }
                if(!socket.isClosed())socket.close();
            }
            if(socket.isConnected())
            {
                socket.close(); 
            }
            socket=null;
        }
        catch(Exception e)
        {
            Log.d("status", "error :( ");
            e.printStackTrace();
        }
    }
    public void connect()
    {
        mManager.discoverPeers(mChannel, new ActionListener() 
        {
            @Override
            public void onSuccess()
            {
                Log.d("status", "1");
            }
            @Override
            public void onFailure(int reason) 
            {
                mManager.cancelConnect(mChannel, new ActionListener() {
                    @Override
                    public void onSuccess()
                    {
                        Log.d("status", "success cancel connect");
                        connect();
                    }
                    @Override
                    public void onFailure(int reason) 
                    {
                        Log.d("status", "failed cancel connect");
                    }
                });
            }
        });
    }
    public static void log(String shusmu)
    {
        Log.d("status", shusmu);
    }
}

最后这是我的主要 Activity 类

package com.example.wifidirect;
import java.io.IOException;
import java.net.UnknownHostException;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.wifi.WifiManager;
import android.net.wifi.p2p.WifiP2pManager;
import android.net.wifi.p2p.WifiP2pManager.Channel;
import android.net.wifi.p2p.WifiP2pManager.PeerListListener;
import android.os.Bundle;
import android.os.StrictMode;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
public class WifiDirect extends Activity 
{
    WifiP2pManager mManager;
    Channel mChannel;
    WiFiDirectBroadcastReceiver mReceiver;
    PeerListListener listener = null;
    IntentFilter mIntentFilter;
    String host;
    Connection con=null;
    PeerListListener myPeerListListener;
    @SuppressLint("NewApi")
    @Override
    public void onCreate(Bundle savedInstanceState) 
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.wifi_direct);
        StrictMode.enableDefaults();
        WifiManager wifiManager  = (WifiManager)this.getSystemService(Context.WIFI_SERVICE);
        wifiManager.setWifiEnabled(true);
        mManager = (WifiP2pManager) getSystemService(Context.WIFI_P2P_SERVICE);
        mChannel = mManager.initialize(this, getMainLooper(), null);
        mReceiver = new WiFiDirectBroadcastReceiver(mManager, mChannel, this);
        mIntentFilter = new IntentFilter();
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
        mIntentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
        try {
            con = new Connection(mReceiver,this,mChannel,mManager);
        } catch (UnknownHostException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        final Button discover = (Button)findViewById(R.id.discover);
        discover.setOnClickListener(new OnClickListener() 
        {
            @Override
            public void onClick(View v) 
            {
                con.connect();
            }
        });
    }
    @Override
    protected void onResume()
    {
        super.onResume();
        registerReceiver(mReceiver, mIntentFilter);
    }
    @Override
    protected void onPause() {
        super.onPause();
    }
    @SuppressLint("NewApi")
    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        con.sendMessage(100);
        unregisterReceiver(mReceiver);
    }
    @SuppressLint("NewApi")
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) 
    {
        // TODO Auto-generated method stub
        super.onActivityResult(requestCode, resultCode, data);
        String action = data.getAction();
        if (WifiP2pManager.WIFI_P2P_PEERS_CHANGED_ACTION.equals(action)) 
        {
            if (mManager != null) 
            {
                mManager.requestPeers(mChannel, myPeerListListener);
            }
        }
    }
    void log(String s)
    {
        Log.d("status ", s);
    }
}

以防万一有人遇到类似的问题，我也遇到了类似的问题，有时会看到连接被拒绝的消息，并通过允许客户端线程休眠一秒钟以防止竞争条件来解决此问题。这个想法是，一旦两个设备连接起来，ConnectionListener 就会被触发。之后，服务器\客户端都会根据角色启动服务器线程或客户端线程。组所有者将发出服务器线程，组成员将启动客户端线程。有时，客户端线程会在服务器线程之前启动，并且客户端线程无法找到要连接的服务器。因此，我为客户端添加了一秒睡眠，以确保服务器线程首先注册。现在，我没有看到问题发生。这是我的代码：

private WifiP2pManager.ConnectionInfoListener connectionListener
  = new WifiP2pManager.ConnectionInfoListener(){
    @Override
    public void onConnectionInfoAvailable(WifiP2pInfo info) {

            // TODO Auto-generated method stub                  
    Log.i(TAG, "onConnectionInfoAvailable");

    //String groupOwnerAddress = info.groupOwnerAddress.getHostAddress();
    if (info.groupFormed && info.isGroupOwner) {
        // Do whatever tasks are specific to the group owner.
        // One common case is creating a server thread and accepting
        // incoming connections.
        Log.i(TAG, "Connected as group owner...");
        WifiDirectServerThread wifiDirectServerThread = new WifiDirectServerThread(context);
        wifiDirectServerThread.execute();

    } else if (info.groupFormed) {
        // The other device acts as the client. In this case,
        // you'll want to create a client thread that connects to the group
        // owner.
        Log.i(TAG, "Connected as group member...");
        Log.i(TAG, "Sleep before launching client thread to avoid race conditions...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        WifiDirectClientDataThread wifiDirectClientThread = new WifiDirectClientDataThread(info.groupOwnerAddress.getHostAddress(), PORT, context);
        wifiDirectClientThread.start();

    }
}

};
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Android

Sockets

Android 连接有时会被拒绝（并非所有时候） 的相关文章

随机推荐

  • Selenium：等到 WebElement 中的文本发生变化

    我在用着selenium使用Python 2 7 从网页上的搜索框检索内容 搜索框动态检索结果并在框本身中显示结果 from selenium import webdriver from selenium webdriver common

  • 如何使用 jquery 从 iframe 内部滚动？

    我正在使用一个 Shadowbox 它生成一个 iframe 以在页面上显示产品详细信息 由于详细信息页面可能相当长 因此客户端需要一个 更多 按钮来向下滚动页面 显然 iframe 右侧的滚动条还不够 这是我为了让 iframe 滚动而尝

  • 如何使用text()函数插入html文本？ [关闭]

    Closed 这个问题不符合堆栈溢出指南 help closed questions 目前不接受答案 我需要更改包含 html 的元素的内容 我尝试过这个 但是 html 标签被打印了 content sections label text

  • Inno Setup 如何在浏览对话框中显示网络？

    在我的设置中 在浏览器中显示 浏览 按钮 wpSelectDir or CreateInputDirPage例如 网络永远不会显示 我对此进行了一段时间的搜索 但目前还没有找到任何解决方案 有没有办法显示网络并让用户选择网络路径 感谢您对此

  • 用于更改向量中元素顺序的闪亮小部件

    在很多网站上 您都有一个拖放界面来更改列表中元素的顺序 我正在寻找类似的东西闪亮 我希望用户能够拖放列表中的元素 通过更改顺序来更改优先级 现在我有一个滥用的解决方案selectizeInput 这是可行的 但当选择列表变得更大时 它很快就

  • Angularjs 在生产中禁用调试数据

    我正在尝试按照角度文档中的建议禁用生产服务器中的调试数据here https docs angularjs org guide production 补充一点 我并没有真正看到性能和加载时间有任何改进 这是我的代码在 app js 中的样子

  • 处理中渲染极地带面体时出现问题

    我最近一直在研究 Zohedrons 和Rob Bell http zomadic com 做出了美丽的 我玩了免费的极地带面体 Sketchup 插件 http zomebuilder com 并考虑使用几何图形加工 http proce

  • Spring Cloud Kubernetes + Spring Cloud Gateway：无法找到 k8s 服务的实例

    我正在使用 Spring Cloud Kubernetes Spring Cloud Gateway SCG 但在 GKE 上部署应用程序时遇到一些问题 SCG 找不到 k8s 服务 我仍然收到此错误 There was an unexpe

  • 如何在编译C代码时禁用警告？

    我正在使用 32 位 Fedora 14 系统 我正在使用编译我的源代码gcc 有谁知道如何在编译c代码时禁用警告 EDIT 是的 我知道 最好的办法是修复这些警告以避免任何未定义 未知的行为 但目前在这里 我第一次编写了巨大的代码 并且在

  • 当 DetailView 遇到时更新模型字段。 [姜戈]

    我有一个类似的 DetailViewviews py views py class CustomView DetailView context object name content model models AppModel templa

  • unsigned char* 缓冲区到 System::Drawing::Bitmap

    我正在尝试创建一个工具 资产转换器 使用以下命令将字体光栅化为 XNA 游戏的纹理页面自由类型2 http www freetype org freetype2 index html engine 下面 第一张图片是FreeType2的直接

  • RSpec 抛出分段错误

    有时我的测试套件会无缘无故地抛出分段错误 这是输出 Users Test rvm gems ruby 1 9 3 p392 gems activerecord 3 2 9 lib active record relation query m

  • 导出类时编译器错误

    我正在使用 Visual Studio 2013 但遇到了一个奇怪的问题 当我导出一个类时 它会抛出 尝试引用已删除的函数 错误 但是 当该类未导出时 它的行为会正确 让我举个例子 class Foo note the export cla

  • Qt 计算和比较密码哈希

    目前正在 Qt 中为测验程序构建面向 Web 的身份验证服务 据我了解 在数据库中存储用户密码时 必须对其进行隐藏 以防落入坏人之手 流行的方法似乎是添加的过程Salt https en wikipedia org wiki Salt cr

  • 为什么 Haskell 中有协函子和逆变函子的区别，而范畴论却没有区别？

    这个答案是从范畴论的角度来看的 https math stackexchange com a 661989 72174包括以下语句 事实是 协函子和逆变函子之间没有真正的区别 因为每个函子只是一个协变函子 More in details a

  • Chart.js 没有显示在我的视图中

    我有一个使用 angular js 运行的应用程序 我的视图之一应该加载图表 我正在使用 Chart js 但由于某种原因它不起作用 并且我的控制台上没有显示错误 这是我创建图表的函数 scope writeBatteryChart fun

  • Yii2 - 如何在用户身份中设置动态 authTimeout？

    在这里 我扩展了UserYii2 的身份 这是我的配置 user gt identityClass gt app models UserMaster class enableAutoLogin gt false loginUrl gt au

  • 如何在多个ec2实例上更改应用程序？

    我是 AWS 新手 谁能告诉我如何更新驻留在多个 ec2 实例上的应用程序的正确方向 我找到了这个答案 如何更新负载均衡的多个 EC2 实例 https stackoverflow com questions 5382427 how do

  • React Native Android 示例不起作用

    我克隆了存储库 https github com facebook react native https github com facebook react native并尝试在 Android 模拟器上运行 UIExplorer 示例 g

  • Android 连接有时会被拒绝（并非所有时候）

    我编写了一个 WiFi Direct 代码连接并在它们之间创建了一个连接 然后我创建了一个ServerSocket在第一面和一个Socket在客户端并开始在它们之间发送数据 第一次启动应用程序时它工作成功 但是当我关闭应用程序并再次启动它时

热门标签