安卓tcp开发（android tcp）

大家好！今天让创意岭的小编来大家介绍下关于安卓tcp开发的问题，以下是小编对此问题的归纳整理，让我们一起来看看吧。

开始之前先推荐一个非常厉害的Ai人工智能工具，一键生成原创文章、方案、文案、工作计划、工作报告、论文、代码、作文、做题和对话答疑等等

只需要输入关键词，就能返回你想要的内容，越精准，写出的就越详细，有微信小程序端、在线网页版、PC客户端

官网：https://ai.de1919.com

本文目录:

• 1、如何搭建 android 开发环境

• 2、多数安卓app和ios app服务器是tcp还是http-C/C++

• 3、安卓app服务器端开发用什么java架构

• 4、android上的socket通信的开源框架有哪些

一、如何搭建 android 开发环境

一.认识android的架构

Android其本质就是在标准的Linux系统上增加了Java虚拟机Dalvik，并在Dalvik虚拟机上搭建了一个JAVA的application framework，所有的应用程序都是基于JAVA的application framework之上。

android分为四个层，从高层到低层分别是应用程序层、应用程序框架层、系统运行库层和linux核心层。

二.搭建环境

搭建开发环境

对国内的开发者来说最痛苦的是无法去访问android开发网站。为了更好的认识世界，对程序员来说，会翻墙也是的一门技术，带你去领略墙外的世界，好了，不废话了, 国内开发者访问(androiddevtools) 上面已经有了所有你要的资源，同时可以下载到我们的主角framework

但是这样的搭建只能去阅读源代码，我们无法去更进一步去实现自己的rom,我们看到锤子的系统在早期的开放rom是自己从新实现了framework的代码，现在看起来他成功了，所以我们还要去搭建android系统的源码编译环境。

搭建源码编译环境

三.开始主题

在一开始写c程序的时候都有一个运行的入口，比如

#include <iostream>

#include <cmath>

#include <algorithm>

using namespace std;

//这里的main就是应用的入口

int main(int argc, const char * argv[]){

return 0;

}

在计算机网络原理中我们用socket实现一个服务器端，不断的接听客户端的访问，而且他的代码是这样实现的：

#include <winsock2.h>

#pragma comment(lib, "WS2_32.lib")

#include <stdio.h>

void main()

{

WORD wVersionRequested;//版本号

WSADATA wsaData;

int err;

wVersionRequested = MAKEWORD(2, 2);//2.2版本的套接字

//加载套接字库,如果失败返回

err = WSAStartup(wVersionRequested, &wsaData);

if (err != 0)

{

return;

}

//判断高低字节是不是2,如果不是2.2的版本则退出

if (LOBYTE(wsaData.wVersion) != 2 ||

HIBYTE(wsaData.wVersion) != 2)

{

return;

}

//创建流式套接字,基于TCP(SOCK_STREAM)

SOCKET socSrv = socket(AF_INET, SOCK_STREAM, 0);

//Socket地址结构体的创建

SOCKADDR_IN addrSrv;

addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);//转换Unsigned long型为网络字节序格

addrSrv.sin_family = AF_INET;//指定地址簇

addrSrv.sin_port = htons(6000);

//指定端口号,除sin_family参数外,其它参数都是网络字节序,因此需要转换

//将套接字绑定到一个端口号和本地地址上

bind(socSrv, (SOCKADDR*)&addrSrv, sizeof(SOCKADDR));//必须用sizeof，strlen不行

listen(socSrv, 5);

SOCKADDR_IN addrClient;//字义用来接收客户端Socket的结构体

int len = sizeof(SOCKADDR);//初始化参数,这个参数必须进行初始化，sizeof

//循环等待接受客户端发送请求

while (1)

{

//等待客户请求到来；当请求到来后，接受连接请求，

//返回一个新的对应于此次连接的套接字（accept）。

//此时程序在此发生阻塞

SOCKET sockConn = accept(socSrv, (SOCKADDR*)&addrClient, &len);

char sendBuf[100];

sprintf(sendBuf, "Welcome %s to JoyChou",

inet_ntoa(addrClient.sin_addr));//格式化输出

//用返回的套接字和客户端进行通信

send(sockConn, sendBuf, strlen(sendBuf)+1, 0);//多发送一个字节

//接收数据

char recvBuf[100];

recv(sockConn, recvBuf, 100, 0);

printf("%s\\n", recvBuf);

closesocket(sockConn);

}

}

他采用了一个while死循环去监听客户端的请求。

先上源代码

public final class ActivityThread {

public static void main(String[] args) {

SamplingProfilerIntegration.start();

CloseGuard.setEnabled(false);

Environment.initForCurrentUser();

EventLogger.setReporter(new EventLoggingReporter());

Security.addProvider(new AndroidKeyStoreProvider());

final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());

TrustedCertificateStore.setDefaultUserDirectory(configDir);

Process.setArgV0("<pre-initialized>");

Looper.prepareMainLooper();

//从中可以看到为app开辟了一个线程进入了looper之中

ActivityThread thread = new ActivityThread();

thread.attach(false);

if (sMainThreadHandler == null) {

sMainThreadHandler = thread.getHandler();

}

AsyncTask.init();

if (false) {

Looper.myLooper().setMessageLogging(new

LogPrinter(Log.DEBUG, "ActivityThread"));

}

Looper.loop();

throw new RuntimeException("Main thread loop unexpectedly exited");

}

}

看到源码失望了，没有一个while循环啊，其实用了他方法实现

//用一个looper的机制循环监听响应

Looper.prepareMainLooper();

Looper.loop();

进一步深入代码

public static void loop() {

final Looper me = myLooper();

if (me == null) {

throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");

}

final MessageQueue queue = me.mQueue;

Binder.clearCallingIdentity();

final long ident = Binder.clearCallingIdentity();

// 在这里看到了一个循环监听消息

for (;;) {

Message msg = queue.next(); // might block

if (msg == null) {

// No message indicates that the message queue is quitting.

return;

}

Printer logging = me.mLogging;

if (logging != null) {

logging.println(">>>>> Dispatching to " + msg.target + " " +

msg.callback + ": " + msg.what);

}

msg.target.dispatchMessage(msg);

if (logging != null) {

logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);

}

// Make sure that during the course of dispatching the

// identity of the thread wasn't corrupted.

final long newIdent = Binder.clearCallingIdentity();

if (ident != newIdent) {

Log.wtf(TAG, "Thread identity changed from 0x"

+ Long.toHexString(ident) + " to 0x"

+ Long.toHexString(newIdent) + " while dispatching to "

+ msg.target.getClass().getName() + " "

+ msg.callback + " what=" + msg.what);

}

msg.recycleUnchecked();

}

}

二、多数安卓app和ios app服务器是tcp还是http-C/C++

看需求，主要是看连接时长。如果是一次性服务，总是由Client发起的，像数据查询/报表填交之类的，httpServer就行。如果需要即时交互的，用TCP，能双通信。

现在做即时性要求不高的像webServer之类的，不用C/C++，被Java的Apacha，Python的Django/Flask/webpy还有其他开发快的各种语言大小框架取而代之。

socket的高通信量/即时性，对性能有要求，高端还是C/C++在做，小型的随意。

三、安卓app服务器端开发用什么java架构

首先，App的服务端跟Web的服务端没有多大区别，而且在实际的开发过程中，业务逻辑也都是共用一套，只是会针对不同的客户端做不同的适配(这点可参考Amazon，其对PC的web端，移动的Web端，移动的App都做了不同程度的适配).

其次，既然与Web的服务端没多大区别，那所用的技术也大同小异，对于App而言，服务端更多是一个数据接口，所以框架页大同小异；

最后，大致总结一下：

技术：

网络通信: tcp，http等；

Web服务：servlet, cgi脚本，asp等；

系统调度：多线程，并发等；

框架：

对应不同的web服务技术，采用的编程语言不同；

对应不同的网络通信协议，采用的框架也不同，netty->tcp，servlet等web服务框架->http等；

对应系统调度，有不同的多线程，多进程通信框架等；

对应提供不同的服务接口，有web service和restful两大类，前者基于soap协议，后者基于http协议，对应的框架就很多，不一一叙述；

除此之外，还有很多其他的技术，可先做，发现问题，自然就知道怎么去找相应的技术、解决方案(包含框架)来解决，所以先动手吧；

四、android上的socket通信的开源框架有哪些

请去360手机助手下载android学习手册里面有例子、源码和文档

Apache MINA(Multipurpose Infrastructure for Network Applications) 是 Apache 组织一个较新的项目，它为开发高性能和高可用性的网络应用程序提供了非常便利的框架。当前发行的 MINA 版本支持基于 Java NIO 技术的 TCP/UDP 应用程序开发、串口通讯程序（只在最新的预览版中提供），MINA 所支持的功能也在进一步的扩展中。目前正在使用 MINA 的软件包括有：Apache Directory Project、AsyncWeb、AMQP（Advanced Message Queuing Protocol）、RED5 Server（Macromedia Flash Media RTMP）、ObjectRADIUS、Openfire 等等。

以上是从网上找到的mina框架简单介绍。

由于正在开发的项目中要求加入及时通信功能（游戏方面），所以在网上找了好几种框架，像openfire、tigase等都是基于Xmpp协议开发的优秀框架。但这些侧重于消息的推送，不适合游戏上的简单交互。所以后来找到了mina这个框架，顺手搭建起来。接下来就是这几天学习的总结了，文章里面没有涉及到逻辑层的方面，只是简单的实现即时通信功能。资源下载我会放在文章的最后面。

一、相关资源下载

（1）Apache官方网站：http://mina.apache.org/downloads.html

(2) Android用jar包（包括官网的资源，我会一律放在百度网盘下）

二、Mina简单配置

服务器端一共要用到四个jar包，包括一个日志包。将他们放在lib中，并加载进去

分别为 mina-core-2.0.7.jar  slf4j-log4j12-1.7.6.jar  slf4j-api-1.7.6.jar  log4j-1.2.14.jar(日志管理包)

如果要使用日志的jar包，则要在项目的src目录下新建一个log4j.properties,添加内容如下：

log4j.rootCategory=INFO, stdout , R  

log4j.appender.stdout=org.apache.log4j.ConsoleAppender  

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout  

log4j.appender.stdout.layout.ConversionPattern=[QC] %p [%t] %C.%M(%L) | %m%n  

log4j.appender.R=org.apache.log4j.DailyRollingFileAppender  

log4j.appender.R.File=D:\Tomcat 5.5\logs\qc.log  

log4j.appender.R.layout=org.apache.log4j.PatternLayout  

1log4j.appender.R.layout.ConversionPattern=%d-[TS] %p %t %c - %m%n  

log4j.logger.com.neusoft=DEBUG  

log4j.logger.com.opensymphony.oscache=ERROR  

log4j.logger.net.sf.navigator=ERROR  

log4j.logger.org.apache.commons=ERROR  

log4j.logger.org.apache.struts=WARN  

log4j.logger.org.displaytag=ERROR  

log4j.logger.org.springframework=DEBUG  

log4j.logger.com.ibatis.db=WARN  

log4j.logger.org.apache.velocity=FATAL  

log4j.logger.com.canoo.webtest=WARN  

log4j.logger.org.hibernate.ps.PreparedStatementCache=WARN  

log4j.logger.org.hibernate=DEBUG  

log4j.logger.org.logicalcobwebs=WARN  

log4j.rootCategory=INFO, stdout , R

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

log4j.appender.stdout.layout.ConversionPattern=[QC] %p [%t] %C.%M(%L) | %m%n

log4j.appender.R=org.apache.log4j.DailyRollingFileAppender

log4j.appender.R.File=D:\Tomcat 5.5\logs\qc.log

log4j.appender.R.layout=org.apache.log4j.PatternLayout

1log4j.appender.R.layout.ConversionPattern=%d-[TS] %p %t %c - %m%n

log4j.logger.com.neusoft=DEBUG

log4j.logger.com.opensymphony.oscache=ERROR

log4j.logger.net.sf.navigator=ERROR

log4j.logger.org.apache.commons=ERROR

log4j.logger.org.apache.struts=WARN

log4j.logger.org.displaytag=ERROR

log4j.logger.org.springframework=DEBUG

log4j.logger.com.ibatis.db=WARN

log4j.logger.org.apache.velocity=FATAL

log4j.logger.com.canoo.webtest=WARN

log4j.logger.org.hibernate.ps.PreparedStatementCache=WARN

log4j.logger.org.hibernate=DEBUG

log4j.logger.org.logicalcobwebs=WARN

Android客户端要加入的jar包：mina-core-2.0.7.jar  slf4j-android-1.6.1-RC1.jar 两个jar包（可能直接使用上面的jar包也会行，我没试过~）

二、Mina服务端

我这边使用的是mina2.0版本，所以可能与mina1.0的版本有所不同。那么首先在服务器端创建开始

新建一个Demo1Server.class文件，里面包含着程序的入口，端口号，Acceptor连接.

1 public class Demo1Server {

2     //日志类的实现

3     private static Logger logger = Logger.getLogger(Demo1Server.class);

4     //端口号，要求客户端与服务器端一致

5     private static int PORT = 4444;

6    

7     public static void main(String[] args){

8         IoAcceptor acceptor = null;

9         try{

10             //创建一个非阻塞的server端的Socket

11             acceptor = new NioSocketAcceptor();

12             //设置过滤器（使用mina提供的文本换行符编解码器）

13             acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"),LineDelimiter.WINDOWS.getValue(),LineDelimiter.WINDOWS.getValue())));

14             //自定义的编解码器

15             //acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new CharsetCodecFactory()));

16             //设置读取数据的换从区大小

17             acceptor.getSessionConfig().setReadBufferSize(2048);

18             //读写通道10秒内无操作进入空闲状态

19             acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);

20             //为接收器设置管理服务

21             acceptor.setHandler(new Demo1ServerHandler());

22             //绑定端口

23             acceptor.bind(new InetSocketAddress(PORT));

24            

25             logger.info("服务器启动成功...    端口号未："+PORT);

26            

27         }catch(Exception e){

28             logger.error("服务器启动异常...",e);

29             e.printStackTrace();

30         }

31     }

32

33 }

一个很简单的程序入口吧，简单的说就是在服务器上设置一个消息接收器，让它监听从端口传过来的消息并进行处理。那么接下来我们看看怎么进行消息处理。

新建一个消息处理类，或者说是是业务逻辑处理器——Demo1ServerHandler，它继承了IoHandlerAdapter类，它默认覆盖了七个方法，而我们主要使用messageReceived()。

public class Demo1ServerHandler extends IoHandlerAdapter {

   public static Logger logger = Logger.getLogger(Demo1ServerHandler.class);

   //从端口接受消息，会响应此方法来对消息进行处理

   @Override

   public void messageReceived(IoSession session, Object message)

           throws Exception {

               String msg = message.toString();

               if("exit".equals(msg)){

                    //如果客户端发来exit，则关闭该连接

                    session.close(true);

                }

       //向客户端发送消息

       Date date = new Date();

       session.write(date);

       logger.info("服务器接受消息成功...");        

       super.messageReceived(session, message);

   }

   //向客服端发送消息后会调用此方法

   @Override

   public void messageSent(IoSession session, Object message) throws Exception {

       logger.info("服务器发送消息成功...");

       super.messageSent(session, message);

   }

   //关闭与客户端的连接时会调用此方法

   @Override

   public void sessionClosed(IoSession session) throws Exception {

       logger.info("服务器与客户端断开连接...");

       super.sessionClosed(session);

   }

   //服务器与客户端创建连接

   @Override

   public void sessionCreated(IoSession session) throws Exception {

       logger.info("服务器与客户端创建连接...");

       super.sessionCreated(session);

   }

   //服务器与客户端连接打开

   @Override

   public void sessionOpened(IoSession session) throws Exception {

       logger.info("服务器与客户端连接打开...");

       super.sessionOpened(session);

   }

   @Override

   public void sessionIdle(IoSession session, IdleStatus status)

           throws Exception {

       logger.info("服务器进入空闲状态...");

       super.sessionIdle(session, status);

   }

   @Override

   public void exceptionCaught(IoSession session, Throwable cause)

           throws Exception {

       logger.info("服务器发送异常...");

       super.exceptionCaught(session, cause);

   }        

}

很直白的一段程序，相当于将服务器分成了七个状态，而每个状态都有自己的一套逻辑处理方案。

至此，一个最简单的Mina服务器框架就搭好了，我们可以使用电脑上的telnet命令来测试一下服务器能否使用

cmd控制台—>telnet <ip地址> <端口号>  如我的服务器ip地为192.168.1.10  那我就写telnet 192.168.1.10 4444 .此时我们可以看到输出日志为

此时连接已经创建，我们在输入信息服务器就会对信息进行处理，并给出相应的应答。

（telnet的用法不知道的可以自行百度）

三、Mina客户端（Android端）

服务器简单搭建完毕，那么开始在Android端是配置服务器吧。同样的不要忘记加载jar包， 由于Android自带了Logout，所以就不使用Mina的日志包了。

由于接受消息会阻塞Android的进程，所以我把它开在子线程中（同时将其放在Service中，让其在后台运行）

1 public class MinaThread extends Thread {

2    

3     private IoSession session = null;

4

5     @Override

6     public void run() {

7         // TODO Auto-generated method stub

8         Log.d("TEST","客户端链接开始...");

9         IoConnector connector = new NioSocketConnector();

10         //设置链接超时时间

11         connector.setConnectTimeoutMillis(30000);

12         //添加过滤器

13         //connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new CharsetCodecFactory()));

14         connector.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"),LineDelimiter.WINDOWS.getValue(),LineDelimiter.WINDOWS.getValue())));

15         connector.setHandler(new MinaClientHandler(minaService));

16        

17         try{

18             ConnectFuture future = connector.connect(new InetSocketAddress(ConstantUtil.WEB_MATCH_PATH,ConstantUtil.WEB_MATCH_PORT));//创建链接

19             future.awaitUninterruptibly();// 等待连接创建完成

20             session = future.getSession();//获得session

21             session.write("start");

22         }catch (Exception e){

23             Log.d("TEST","客户端链接异常...");

24         }

25         session.getCloseFuture().awaitUninterruptibly();//等待连接断开

26         Log.d("TEST","客户端断开...");

27         connector.dispose();

28         super.run();

29     }

30

31 }

不知道你们注意到了没，客户端的代码与服务器端的极其相似，不同的是服务器是创建NioSocketAcceptor对象，而客户端是创建NioSocketConnect对象。当然同样需要添加编码解码过滤器和业务逻辑过滤器。

业务逻辑过滤器代码：

1 public class MinaClientHandler extends IoHandlerAdapter{

2

3

4     @Override

5     public void exceptionCaught(IoSession session, Throwable cause)

6             throws Exception {

7         Log.d("TEST","客户端发生异常");

8         super.exceptionCaught(session, cause);

9     }

10

11     @Override

12     public void messageReceived(IoSession session, Object message)

13             throws Exception {

14         String msg = message.toString();

15         Log.d("TEST","客户端接收到的信息为:" + msg);

16         super.messageReceived(session, message);

17     }

18

19     @Override

20     public void messageSent(IoSession session, Object message) throws Exception {

21         // TODO Auto-generated method stub

22         super.messageSent(session, message);

23     }

24 }

方法功能与服务器端一样。测试这里就不做了。可以的话自己写个Demo效果更好

四、Mina的更多功能

拿到所有客户端Session

Collection<IoSession> sessions = session.getService().getManagedSessions().values();

自定义编码解码器，可以对消息进行预处理。要继承ProtocolEncoder和ProtocolDecode类。

数据对象的传递

这些功能不便放在这里讲了，可能我会以后再找机会另开一篇来讲述这些功能~，大家可以浏览结尾处的参考文章来加深对mina的理解。

在我认为，熟悉和快速使用一个新的的框架可以看出一个程序员的水平，同样及时总结和归纳自己学到的新知识也是一个好的程序员该具有的习惯。那么Mina的简单搭建就到这里为止了，希望对大家有所帮助

以上就是关于安卓tcp开发相关问题的回答。希望能帮到你，如有更多相关问题，您也可以联系我们的客服进行咨询，客服也会为您讲解更多精彩的知识和内容。

推荐阅读：

手机房屋3d设计软件（手机房屋3d设计软件安卓下载）

安卓wechat海外版（微信海外版wechat）

安卓手机怎么打开油管（安卓手机怎么打开油管视频）

云闪付开通后安全吗（云闪付开通后安全吗）

上海绿化景观设计说明（上海园林绿化景观设计）