语源科技BlogJava-Terry Zou

搭建React环境，运行React项目

Terry Zou — Thu, 16 Apr 2020 07:25:00 GMT

1.必须安装nodejs
2.安装cnpm用cnpm替代npm
地址：http://npm.taobao.org/

安装cnpm:

npm install -g cnpm --registry=https://registry.npm.taobao.org

3、用yarn替代npm

yarn的安装：

第一种方法：参考官方文档https://yarn.bootcss.com/

第二种方法：cnpm install -g yarn 或者 npm install -g yarn

4、搭建React开发环境的第一种方法（老-现在推荐）：

https://reactjs.org/docs/create-a-new-react-app.html

1、必须要安装nodejs 注意：安装nodejs稳定版本教程中的nodejs版本:v8.11.2 教程中的npm版本:v5.6.0

2.安装脚手架工具（单文件组件项目生成工具）只需要安装一次

npm install -g create-react-app / cnpm install -g create-react-app

3.创建项目（可能创建多次）

找到项目要创建的目录：

create-react-app reactdemo

4.cd 到项目里面

cd reactdemo

npm start yarn start运行项目

npm run build yarn build 生成项目

5、搭建React的开发环境的第二种方法（新-未来推荐）：

https://reactjs.org/docs/create-a-new-react-app.html

1、必须要安装nodejs 注意：安装nodejs稳定版本教程中的nodejs版本:v8.11.2 教程中的npm版本:v5.6.0

2.安装脚手架工具并创建项目

找到项目要创建的目录执行：

npx create-react-app reactdemo

4.cd 到项目里面

cd reactdemo

npm start 运行项目（调试）

npm run build 生成项目（发布）

npx介绍：

npm v5.2.0引入的一条命令（npx），引入这个命令的目的是为了提升开发者使用包内提供的命令行工具的体验。

详情：

npx create-react-app reactdemo这条命令会临时安装 create-react-app 包，命令完成后create-react-app 会删掉，不会出现在 global 中。下次再执行，还是会重新临时安装。

npx 会帮你执行依赖包里的二进制文件。

再比如 npx http-server 可以一句话帮你开启一个静态服务器

Terry Zou 2020-04-16 15:25 发表评论

Spring @PostConstruct 、@Autowired和Construct 顺序

Terry Zou — Thu, 09 Apr 2020 07:29:00 GMT

@PostConstruct

PostConstruct注释用于在完成依赖项注入以执行任何初始化之后需要执行的方法。必须在类投入使用之前调用此方法。
所有支持依赖注入的类都必须支持此注释。即使类没有请求注入任何资源，也必须调用使用PostConstruct注释的方法。
只有一个方法可以使用此批注进行批注。
应用PostConstruct注释的方法必须满足以下所有条件：除了拦截器之外，方法绝不能有任何参数，在这种情况下它采用Interceptor规范定义的InvocationContext对象。
在拦截器类上定义的方法必须具有以下签名之一：
void <METHOD>（InvocationContext）Object <METHOD>（InvocationContext）抛出异常注意：
PostConstruct拦截器方法不能抛出应用程序异常，但可以声明它抛出检查异常，包括java.lang.Exception，
如果相同的拦截器方法除了生命周期事件之外插入业务或超时方法。
如果PostConstruct拦截器方法返回一个值，容器将忽略它。
在非拦截器类上定义的方法必须具有以下签名：void <METHOD>（）应用PostConstruct的方法可以是public，protected，package private或private。
除应用程序客户端外，该方法绝不能是静态的。
该方法可能是最终的。如果该方法抛出一个未经检查的异常，那么该类绝不能投入使用，除非EJB可以处理异常甚至从它们恢复的EJB

然后就会思考问题，这个注释是修饰初始化之后需要执行的方法，那么它和@Autowired、构造函数的执行顺序是什么呢？（当然注释中已经说明了PostConstruct注释用于在完成依赖项注入之后）

@Service
public class BeanA {

    @Autowired
    private BeanB beanB;

    public BeanA() {
        System.out.println("这是Bean A 的构造方法");
    }
    @PostConstruct
    private void init() {
        System.out.println("这是BeanA的 init 方法");
        beanB.testB();
    }
}

@Service
public class BeanB {

    @PostConstruct
    private void init() {
        System.out.println("这是BeanB 的init 方法");
    }
    public BeanB() {
        System.out.println("这是Bean B的构造方法");
    }
    void testB() {
        System.out.println("这是Bean B 的 testB 方法");
    }
}

启动后输出:

这是Bean A 的构造方法 
这是Bean B的 构造方法 
这是BeanB 的init 方法 
这是BeanA的 init 方法 
这是Bean B 的 testB 方法

所以得到结论： 构造方法 > @Autowired > @PostConstruct

Terry Zou 2020-04-09 15:29 发表评论

Spring中的ApplicationListener的使用详解案例（观察者模式)

Terry Zou — Thu, 09 Apr 2020 06:47:00 GMT

1、ApplicationContext

Spring的核心，Context我们通常解释为上下文环境。ApplicationContext则是应用的容器。 Spring把Bean（object）放在容器中，需要用就通过get方法取出来。在ApplicationContext接口的众多实现类中，有3个是我们经常用到的（见表1-1），并且使用这3个实现类也基本能满足我们Java EE应用开发中的绝大部分需求。

表1-1 ApplicationContext接口的常用实现类介绍

ClassPathXmlApplicationContext

从类路径ClassPath中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作。例如： //装载单个配置文件实例化ApplicationContext容器

ApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");

//装载多个配置文件实例化ApplicationContext容器

String[] configs = {"bean1.xml","bean2.xml","bean3.xml"};

ApplicationContext cxt = new ClassPathXmlApplicationContext(configs);

FileSystemXmlApplicationContext

从指定的文件系统路径中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作。例如：//装载单个配置文件实例化ApplicationContext容器

ApplicationContext cxt = new FileSystemXMLApplicationContext("beans.xml");

//装载多个配置文件实例化ApplicationContext容器

String[] configs = {"c:/beans1.xml","c:/beans2.xml"};

ApplicationContext cxt = new FileSystemXmlApplicationContext(configs);

XmlWebApplicationContext

从Web应用中寻找指定的XML配置文件，找到并装载完成ApplicationContext的实例化工作。这是为Web工程量身定制的，使用WebApplicationContextUtils类的getRequiredWebApplicationContext方法可在JSP与Servlet中取得IoC容器的引用

2、ApplicationEvent
是个抽象类，里面只有一个构造函数和一个长整型的timestamp。其源码如下

public abstract class ApplicationEvent extends EventObject {

    /** use serialVersionUID from Spring 1.2 for interoperability */
    private static final long serialVersionUID = 7099057708183571937L;

    /** System time when the event happened */
    private final long timestamp;

    /**
     * Create a new ApplicationEvent.
     * @param source the object on which the event initially occurred (never {@code null})
     */
    public ApplicationEvent(Object source) {
        super(source);
        this.timestamp = System.currentTimeMillis();
    }

    /**
     * Return the system time in milliseconds when the event happened.
     */
    public final long getTimestamp() {
        return this.timestamp;
    }
}

3、ApplicationListener

是一个接口，里面只有一个onApplicationEvent方法。如果在上下文中部署一个实现了ApplicationListener接口的bean,那么每当在一个ApplicationEvent发布到 ApplicationContext时，调用ApplicationContext.publishEvent()方法，这个bean得到通知。类似于Oberver设计模式。

其源码如下：

public interface ApplicationListenerextends ApplicationEvent> extends EventListener {
    /**
     * Handle an application event.
     * @param event the event to respond to
     */
    void onApplicationEvent(E event);

}

下面举个例子
自定义事件NotifyEvent:

import org.springframework.context.ApplicationEvent;

public class NotifyEvent  extends ApplicationEvent  {
    private String email;
    private String content;
    public NotifyEvent(Object source){
        super(source);
    }

    public NotifyEvent(Object source,String email,String content){
        super(source);
        this.email = email;
        this.content = content;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
}

定义监听器NotifyListener:

import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;

@Configuration
public class NotifyListener implements ApplicationListener{
    @Override
    public void onApplicationEvent(NotifyEvent event) {
        System.out.println("邮件地址：" + event.getEmail());
        System.out.println("邮件内容：" + event.getContent());
    }
}

单元测试类ListenerTest：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.web.context.WebApplicationContext;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = ServerLauncher.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class ListenerTest {
    @Autowired
    private WebApplicationContext webApplicationContext;

    @Test
    public void testListener(){
        NotifyEvent event = new NotifyEvent("object","abc@qq.com","This is the content");
        webApplicationContext.publishEvent(event);
    }
}

Terry Zou 2020-04-09 14:47 发表评论

@SpringBootApplication的使用

Terry Zou — Thu, 09 Apr 2020 01:10:00 GMT

之前用户使用的是3个注解注解他们的main类。分别是@Configuration,@EnableAutoConfiguration,@ComponentScan。由于这些注解一般都是一起使用，spring boot提供了一个统一的注解@SpringBootApplication。

@SpringBootApplication = (默认属性)@Configuration + @EnableAutoConfiguration + @ComponentScan。

@SpringBootApplication
public class ApplicationMain {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

分开解释@Configuration,@EnableAutoConfiguration,@ComponentScan。
1、@Configuration：提到@Configuration就要提到他的搭档@Bean。使用这两个注解就可以创建一个简单的spring配置类，可以用来替代相应的xml配置文件。

    class="com.test.Car">


    class="com.test.Wheel">

相当于：

@Configuration
public class Conf {
    @Bean
    public Car car() {
        Car car = new Car();
        car.setWheel(wheel());
        return car;
    }
    @Bean
    public Wheel wheel() {
        return new Wheel();
    }
}

@Configuration的注解类标识这个类可以使用Spring IoC容器作为bean定义的来源。@Bean注解告诉Spring，一个带有@Bean的注解方法将返回一个对象，该对象应该被注册为在Spring应用程序上下文中的bean。

2、@EnableAutoConfiguration：能够自动配置spring的上下文，试图猜测和配置你想要的bean类，通常会自动根据你的类路径和你的bean定义自动配置。

3、@ComponentScan：会自动扫描指定包下的全部标有@Component的类，并注册成bean，当然包括@Component下的子注解@Service,@Repository,@Controller。

Terry Zou 2020-04-09 09:10 发表评论

服务器连接

Terry Zou — Mon, 13 Jul 2015 14:10:00 GMT

package com.zhihe.xqsh.utils;

import java.io.File;

import java.io.FileOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.io.UnsupportedEncodingException;

import java.util.Date;

import java.util.List;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.HttpStatus;

import org.apache.http.HttpVersion;

import org.apache.http.NameValuePair;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.entity.UrlEncodedFormEntity;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.client.methods.HttpPost;

import org.apache.http.conn.ClientConnectionManager;

import org.apache.http.conn.params.ConnManagerParams;

import org.apache.http.conn.params.ConnRouteParams;

import org.apache.http.conn.scheme.PlainSocketFactory;

import org.apache.http.conn.scheme.Scheme;

import org.apache.http.conn.scheme.SchemeRegistry;

import org.apache.http.conn.ssl.SSLSocketFactory;

import org.apache.http.impl.client.DefaultHttpClient;

import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;

import org.apache.http.impl.cookie.BasicClientCookie;

import org.apache.http.params.BasicHttpParams;

import org.apache.http.params.HttpConnectionParams;

import org.apache.http.params.HttpParams;

import org.apache.http.params.HttpProtocolParams;

import org.apache.http.util.EntityUtils;

import com.zhihe.xqsh.network.ServerErrorException;

import android.accounts.NetworkErrorException;

import android.annotation.SuppressLint;

import android.util.Log;

public class CustomerHttpClient {

private static final String TAG = CustomerHttpClient.class.getSimpleName();

private static DefaultHttpClient customerHttpClient;

private CustomerHttpClient() {

}

public static synchronized HttpClient getHttpClient() {

if (null == customerHttpClient) {

HttpParams params = new BasicHttpParams();

// 设置�?��基本参数

HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);

HttpProtocolParams.setContentCharset(params, "UTF-8");

HttpProtocolParams.setUseExpectContinue(params, true);

HttpProtocolParams.setUserAgent(params, "Mozilla/5.0(Linux;U;Android 2.2.1;en-us;Nexus One Build.FRG83) "

+ "AppleWebKit/553.1(KHTML,like Gecko) Version/4.0 Mobile Safari/533.1");

// 超时设置

/* 从连接池中取连接的超时时�?*/

ConnManagerParams.setTimeout(params, 2000);

ConnManagerParams.setMaxTotalConnections(params, 800);

/* 连接超时 */

HttpConnectionParams.setConnectionTimeout(params, 5000);

/* 请求超时 */

HttpConnectionParams.setSoTimeout(params, 10000);

// 设置我们的HttpClient支持HTTP和HTTPS两种模式

SchemeRegistry schReg = new SchemeRegistry();

schReg.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));

schReg.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));

// 使用线程安全的连接管理来创建HttpClient

ClientConnectionManager conMgr = new ThreadSafeClientConnManager(params, schReg);

// �?��连接数：ConnManagerParams.setMaxTotalConnections(params, 50);

customerHttpClient = new DefaultHttpClient(conMgr, params);

}

return customerHttpClient;

}

/**

* 以get方式提交数据

* @param url 提交地址

* @param params 参数

* @return 响应结果

* @throws ServerErrorException 请求失败

* @throws NetworkErrorException 连接失败

public static String get(String url, String params) throws ServerErrorException, NetworkErrorException {

int tryTimes = 0;

NullPointerException ex;

do {

try {

return tryGet(url, params);

} catch (NullPointerException e) {

ex = e;

tryTimes++;

}

} while (tryTimes < 3);

throw ex;

}

/**

* 以get方式提交数据

* @param url 提交地址

* @param params 参数

* @return 响应结果

* @throws ServerErrorException 请求失败

* @throws NetworkErrorException 连接失败

public static String tryGet(String url, String params) throws ServerErrorException, NetworkErrorException {

try {

HttpGet request = new HttpGet(url + params);

/*if (LotteryApplication.isCmwap()) {

org.apache.http.HttpHost proxy = new org.apache.http.HttpHost("10.0.0.172", 80, "http");

HttpParams httpParams = new BasicHttpParams();

ConnRouteParams.setDefaultProxy(httpParams, proxy);

request.setParams(httpParams);

}*/

HttpClient client = getHttpClient();

HttpResponse response = client.execute(request);

if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {

throw new ServerErrorException("��æ��Ժ��");

}

HttpEntity resEntity = response.getEntity();

String result = (resEntity == null) ? null : EntityUtils.toString(resEntity, "UTF-8");

return result;

} catch (UnsupportedEncodingException e) {

logw(e.getMessage());

return null;

} catch (ClientProtocolException e) {

logw(e.getMessage());

return null;

} catch (IOException e) {

throw new NetworkErrorException("��Ӳ��ɹ��", e);

}

private static void logw(String string) {

if (string != null) {

Log.w(TAG, string);

}

/**

* 以post方式提交数据

* @param url 提交地址

* @param params 参数

* @return 响应结果

* @throws ServerErrorException 请求失败

* @throws NetworkErrorException 连接失败

public static String post(String url, List params) throws ServerErrorException, NetworkErrorException {

return post(url, params, null);

}

/**

* 以post方式提交数据

* @param url 提交地址

* @param params 参数

* @param soTimeout 响应超时时间，单位毫�?

* @return 响应结果

* @throws ServerErrorException 请求失败

* @throws NetworkErrorException 连接失败

public static String post(String url, List params, int soTimeout) throws ServerErrorException,

NetworkErrorException {

HttpParams httpParams;

if (soTimeout <= 0) {

httpParams = null;

} else {

httpParams = new BasicHttpParams();

HttpConnectionParams.setSoTimeout(httpParams, soTimeout);

}

return post(url, params, httpParams);

}

/**

* 以post方式提交数据

* @param url 提交地址

* @param params 参数

* @param httpParams http参数

* @return 响应结果

* @throws ServerErrorException 请求失败

* @throws NetworkErrorException 连接失败

public static String post(String url, List params, HttpParams httpParams) throws ServerErrorException,

NetworkErrorException {

int tryTimes = 0;

NullPointerException ex;

do {

try {

return tryPost(url, params, httpParams);

} catch (NullPointerException e) {

ex = e;

tryTimes++;

}

} while (tryTimes < 3);

throw ex;

}

/**

* 以post方式提交数据

* @param url 提交地址

* @param params 参数

* @param httpParams http参数

* @return 响应结果

* @throws ServerErrorException 请求失败

* @throws NetworkErrorException 连接失败

public static String tryPost(String url, List params, HttpParams httpParams) throws ServerErrorException,

NetworkErrorException {

try {

HttpPost request = new HttpPost(url);

if (params != null && params.size() > 0) {

request.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));

}

// if (LotteryApplication.isCmwap()) {

// org.apache.http.HttpHost proxy = new org.apache.http.HttpHost("10.0.0.172", 80, "http");

// if (httpParams == null)

// httpParams = new BasicHttpParams();

// ConnRouteParams.setDefaultProxy(httpParams, proxy);

// }

if (httpParams != null)

request.setParams(httpParams);

//Log.v("CS", params.toString());

HttpClient client = getHttpClient();

HttpResponse response = client.execute(request);

if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {

//Log.v("CS", params.toString());

//Log.v("CS", response.getStatusLine().getStatusCode() + "");

request.abort();

throw new ServerErrorException("��æ��Ժ��");

}

if (response.getStatusLine ().getStatusCode () != 200) {

request.abort(); //�ж��,��Կ�ʼ��һ��

return null;

}

HttpEntity resEntity = response.getEntity();

String result = (resEntity == null) ? null : EntityUtils.toString(resEntity, "UTF-8");

//Log.v("CS", params.toString() + "||||" + result);

return result;

} catch (UnsupportedEncodingException e) {

logw(e.getMessage());

return null;

} catch (ClientProtocolException e) {

logw(e.getMessage());

return null;

} catch (IOException e) {

throw new NetworkErrorException(e.getMessage(), e);

//throw new NetworkErrorException("连接不成功，请检查网络设�?, e);

}

@SuppressLint("SdCardPath")

public static String download(String url) throws ServerErrorException, NetworkErrorException {

try {

//Log.i("http-download", url);

HttpPost request = new HttpPost(url);

HttpClient client = getHttpClient();

HttpResponse response = client.execute(request);

if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {

throw new ServerErrorException("��æ��Ժ��");

}

HttpEntity entity = response.getEntity();

InputStream is = entity.getContent();

if (is == null)

throw new ServerErrorException("stream is null ");

String fileExt = url.substring(url.lastIndexOf(".") + 1, url.length()).toLowerCase();

String fileName = url.substring(url.lastIndexOf("/") + 1, url.lastIndexOf("."));

File tempFile = new File("/sdcard/" + fileName + "." + fileExt);

if (!tempFile.exists())

tempFile.createNewFile();

FileOutputStream fileOutputStream = new FileOutputStream(tempFile);

byte[] buf = new byte[1024];

int ch;

while ((ch = is.read(buf)) != -1) {

fileOutputStream.write(buf, 0, ch);

}

fileOutputStream.flush();

fileOutputStream.close();

return tempFile.getAbsolutePath();

} catch (UnsupportedEncodingException e) {

logw(e.getMessage());

return null;

} catch (ClientProtocolException e) {

logw(e.getMessage());

return null;

} catch (IOException e) {

throw new NetworkErrorException(e.getMessage(), e);

}

/**

* 清空cookie

public static void clearCookie() {

if (customerHttpClient != null)

customerHttpClient.getCookieStore().clear();

}

/**

* 清除指定cookie

* @param name cookie名称

public static void clearCookie(String name) {

if (customerHttpClient == null)

return;

BasicClientCookie expiredCookie = new BasicClientCookie(name, "null");

expiredCookie.setExpiryDate(new Date(System.currentTimeMillis() - 1000));

customerHttpClient.getCookieStore().addCookie(expiredCookie);

}

Terry Zou 2015-07-13 22:10 发表评论

ffg

Terry Zou — Mon, 13 Jul 2015 03:04:00 GMT

http://yunpan.cn/ccdbTgQaYa4U7

Terry Zou 2015-07-13 11:04 发表评论

abe

Terry Zou — Wed, 08 Jul 2015 16:04:00 GMT

private Drawable img_time_filter,img_time_filter_selected ;

//过滤器TextView中显示的图片

img_time_filter = getResources().getDrawable(R.drawable.time_filter);

//调用setCompoundDrawables时，必须调用Drawable.setBounds()方法,否则图片不显示

img_time_filter.setBounds(0, 0, img_time_filter.getMinimumWidth(), img_time_filter.getMinimumHeight());

img_time_filter_selected = getResources().getDrawable(R.drawable.time_filter_selected);

img_time_filter_selected.setBounds(0, 0, img_time_filter_selected.getMinimumWidth(), img_time_filter_selected.getMinimumHeight());

tv_filterTime.setCompoundDrawables(img_time_filter_selected, null, null, null);

tv_filterTime.setTextColor(getResources().getColor(R.color.white));

rl_filterTime.setBackgroundColor(getResources().getColor(R.color.red));

tv_filterTime.setCompoundDrawables(img_time_filter, null, null, null);

rl_filterTime.setBackgroundColor(getResources().getColor(R.color.white));

lv_filterTime.setVisibility(View.INVISIBLE);

Terry Zou 2015-07-09 00:04 发表评论

Android之Activity的四种启动模式

Terry Zou — Wed, 24 Jun 2015 10:10:00 GMT

转载：http://www.cnblogs.com/allenzheng/archive/2013/04/28/3050065.html
当应用运行起来后就会开启一条线程，线程中会运行一个任务栈，当Activity实例创建后就会放入任务栈中。Activity启动模式的设置在AndroidManifest.xml文件中，通过配置Activity的属性android:launchMode=""设置。

1. Standared模式（默认）

我们平时直接创建的Activity都是这种模式的Activity，这种模式的Activity的特点是：只要你创建了Activity实例，一旦激活该Activity，则会向任务栈中加入新创建的实例，退出Activity则会在任务栈中销毁该实例。

2. SingleTop模式

这种模式会考虑当前要激活的Activity实例在任务栈中是否正处于栈顶，如果处于栈顶则无需重新创建新的实例，会重用已存在的实例，否则会在任务栈中创建新的实例。

3. SingleTask模式

如果任务栈中存在该模式的Activity实例，则把栈中该实例以上的Activity实例全部移除，调用该实例的newInstance()方法重用该Activity，使该实例处於栈顶位置，否则就重新创建一个新的Activity实例。

4. SingleInstance模式

当该模式Activity实例在任务栈中创建后，只要该实例还在任务栈中，即只要激活的是该类型的Activity，都会通过调用实例的newInstance()方法重用该Activity，此时使用的都是同一个Activity实例，它都会处于任务栈的栈顶。此模式一般用于加载较慢的，比较耗性能且不需要每次都重新创建的Activity。

Terry Zou 2015-06-24 18:10 发表评论

android中跨进程通讯的4种方式

Terry Zou — Wed, 24 Jun 2015 09:28:00 GMT

摘要: android中跨进程通讯的4种方式转自：http://www.cnblogs.com/sevenyuan/archive/2013/03/22/2975122.html由于android系统中应用程序之间不能共享内存。因此，在不同应用程序之间交互数据（跨进程通讯）就稍微麻烦一些。在android SDK中提供了4种用于跨进程通讯的方式。这4种方式正好对应于android系统中4种应用... 阅读全文

Terry Zou 2015-06-24 17:28 发表评论

Android 一个应用中只有一个进程么？还是可以有多个

Terry Zou — Wed, 24 Jun 2015 09:12:00 GMT

Android 手机上的应用一般情况下都在一个进程中运行。

但是，也可以指定Activity或者Service在Remote 进程中执行。多数情况下，只有在用户认为应用退出后还需要继续后台长期运行的应用，才需要这样做。此时，该应用有两个进程。

还有一种hack的方式，在apk中通过调用命令行来启动另外的进程。此种方式用户不可见，也不安全。不提倡。

Terry Zou 2015-06-24 17:12 发表评论