您的位置：首页 > 移动开发 > Android开发

Android组件Service学习

2014-11-27 19:19 405 查看

富貴必從勤苦得，男兒須讀五車書。唐.杜甫《柏學士茅屋》

作为程序员的我们，须知富贵是要通过勤苦努力才能得到的，要想在行业内有所建树，就必须刻苦学习和钻研。

今天我们来讲一下Android中Service的相关内容。

Service在Android中和Activity是属于同一级别上的组件，我们可以将他们认为是两个好哥们，Activity仪表不凡，迷倒万千少女，经常做一些公众人物角色，而Service一副彪悍的长相，但却身强力壮，常常在后台做一些搬运工的力气活，虽然有些累，但大家都不能失去他。

下面我们就围绕Service对其进行全面讲解：

1.Service生命周期

Service生命周期可以从两种启动Service的模式开始讲起，分别是context.startService()和context.bindService()。

(1).startService的启动模式下的生命周期：当我们首次使用startService启动一个服务时，系统会实例化一个Service实例，依次调用其onCreate和onStartCommand方法，然后进入运行状态，此后，如果再使用startService启动服务时，不再创建新的服务对象，系统会自动找到刚才创建的Service实例，调用其onStart方法；如果我们想要停掉一个服务，可使用stopService方法，此时onDestroy方法会被调用，需要注意的是，不管前面使用了多个次startService，只需一次stopService，即可停掉服务。

(2).bindService启动模式下的生命周期：在这种模式下，当调用者首次使用bindService绑定一个服务时，系统会实例化一个Service实例，并一次调用其onCreate方法和onBind方法，然后调用者就可以和服务进行交互了，此后，如果再次使用bindService绑定服务，系统不会创建新的Service实例，也不会再调用onBind方法；如果我们需要解除与这个服务的绑定，可使用unbindService方法，此时onUnbind方法和onDestroy方法会被调用。

两种模式有以下几点不同之处：startService模式下调用者与服务无必然联系，即使调用者结束了自己的生命周期，只要没有使用stopService方法停止这个服务，服务仍会运行；通常情况下，bindService模式下服务是与调用者生死与共的，在绑定结束之后，一旦调用者被销毁，服务也就立即终止，就像江湖上的一句话：不求同生，但愿同死。

值得一提的是，以前我们在使用startService启动服务时都是习惯重写onStart方法，在Android2.0时系统引进了onStartCommand方法取代onStart方法，为了兼容以前的程序，在onStartCommand方法中其实调用了onStart方法，不过我们最好是重写onStartCommand方法。

以上两种模式的流程如下图所示：

下面结合列子看看第一种生命周期：Unbounded

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    public void start(View view){
    	Intent intent = new Intent(this,MyService.class);
    	//通知框架开启服务。
    	startService(intent);
    }
    public void stop(View view){
    	Intent intent = new Intent(this,MyService.class);
    	stopService(intent);
    }
    
    @Override
    protected void onDestroy() {
    	System.out.println("啊啊啊，我是activity，我挂了");
    	super.onDestroy();
    }
    //调用服务里面的方法。不可以自己new服务，调用的服务的方法，必须通过框架得到服务的引用。
    public void call(View view){
    
    }
}

Service如下:

public class MyService extends Service {
	@Override
	public IBinder onBind(Intent arg0) {
		return null;
	}
	@Override
	public void onCreate() {
		System.out.println("oncreate");
		super.onCreate();
	}
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		System.out.println("onstartcommand");
		return super.onStartCommand(intent, flags, startId);
	}
	@Override
	public void onDestroy() {
		System.out.println("ondestory");
		super.onDestroy();
	}
	/**
	 * 这是服务里面的一个方法
	 */
	public void methodInService(){
		Toast.makeText(this, "哈哈，我是服务里面的方法", 0).show();
	}
}

实现界面如下：

当我们单击开启服务时候：

不管单击多少次，服务只执行onCreate（）方法一次，然后onstartcommand()可以执行多次：

单击：停止服务时

调用ondestory（）一次。

这种方式启用服务时，生命周期如下：

开启服务： onCreate()--> onStartCommand() ---> onDestory();

如果服务已经开启，不会重复的执行onCreate()，而是会调用onStart()和 onStartCommand();

服务停止的时候 onDestory().

服务只会被停止一次

单击调用服务里面的方法按钮，无响应。这种情况下是无法执行服务里面的方法的。

Bind方式开启服务：

看看原理图

实例代码如下：

public class MainActivity extends Activity {
	private MyConn conn ;
	private IMiddlePerson mp;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    //绑定服务
    public void bind(View view){
    	//3.activity采用绑定的方式去开启服务。
    	Intent intent = new Intent(this,MyService.class);
    	conn = new MyConn();
    	bindService(intent, conn, BIND_AUTO_CREATE);
    }
    //解除绑定服务
    public void unbind(View view){
    	unbindService(conn);
    }
    
    @Override
    protected void onDestroy() {
    	System.out.println("啊啊啊，我是activity，我挂了");
    	super.onDestroy();
    }
    //调用服务里面的方法。
    public void call(View view){
    	//5.通过中间人调用服务里面的方法。
    	mp.callMethodInService(55);
    }
    private class MyConn implements ServiceConnection{
    	//4. 当服务被连接的时候调用 服务别成功 绑定的时候调用
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			System.out.println("在activity里面成功得到了中间人");
			mp = (IMiddlePerson) service;
		}
		//当服务失去连接的时候调用（一般进程挂了，服务被异常杀死）
		@Override
		public void onServiceDisconnected(ComponentName name) {
			
		}
    }
}

Service:

public class MyService extends Service {
	//2.实现服务成功绑定的代码 ，返回一个中间人。
	@Override
	public IBinder onBind(Intent arg0) {
		System.out.println("服务被成功绑定了。。。。");
		return new MiddlePerson();
	}
	
	@Override
	public boolean onUnbind(Intent intent) {
		System.out.println("onunbind");
		return super.onUnbind(intent);
	}
	
	@Override
	public void onCreate() {
		System.out.println("oncreate");
		super.onCreate();
	}
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		System.out.println("onstartcommand");
		return super.onStartCommand(intent, flags, startId);
	}
	@Override
	public void onDestroy() {
		System.out.println("ondestory");
		super.onDestroy();
	}
	
	
	
	
	/**
	 * 这是服务里面的一个方法
	 */
	public void methodInService(){
		Toast.makeText(this, "哈哈，服务给你办好了暂住证。", 0).show();
	}
	//1.第一步服务要暴露方法 必须要有一个中间人
	private class MiddlePerson extends Binder implements IMiddlePerson{
		/**
		 * 代办暂住证
		 * @param money 给钱 50块钱以上才给办。
		 */
		public void callMethodInService(int money){
			if(money>=50){
				methodInService();
			}else{
				Toast.makeText(getApplicationContext(), "多准备点钱。", 0).show();
			}
		}
		/**
		 * 陪领导打麻将
		 */
		public void playMajiang(){
			System.out.println("陪领导打麻将。");
		}
	}
}

为了实现服务里面方法的安全性，写了一个中间人的接口，这样，只有接口中含有的方法，服务才会暴露在外面。

/**
 * 中间人的接口定义
 *
 */
public interface IMiddlePerson {
	/**
	 * 代办暂住证
	 * @param money
	 */
	public void callMethodInService(int money);
}

运行的界面如下：

单击并多次单击绑定服务的时候：

此时调用的方法是：onCreate（）---》onBind（）--》onServiceConnected（）【服务连接成功时调用的方法】。

单击调用服务里面的方法的时候，成功调用：

说明bind方式启用服务的时候，是可以实现调用服务里面的方法的。

调用了onbound方法

所以生命周期为：

onCreate() --->onBind();--->onunbind()-->onDestory();【但是我实验的时候，并没有看到onDesory方法执行】

绑定服务不会调用onstart或者onstartcommand方法；

这种绑定服务的方法需要注意步骤：5点【上面已注释1.2.3.4.5.非常重要]

两种服务的比较：

三、两种开启服务方法的区别。

start方式开启服务。一旦服务开启跟调用者(开启者)就没有任何关系了。

开启者退出了，开启者挂了，服务还在后台长期的运行。

开启者没有办法去调用服务里面的方法。（美国的司法独立）

bind的方式开启服务，绑定服务，调用者挂了，服务也会跟着挂掉。不求同时生，但求同时死。

开启者可以调用服务里面的方法。

下面看看远程服务，在一个程序中，通过aidl规范，实现进程间的通信，打开服务。

先看看两个工程【对应两个进程】的包结构

这里可以搜搜AIDL相关的知识，Android中进程间的通信.

服务端代码

public class MainActivity extends Activity {

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu) {
		// Inflate the menu; this adds items to the action bar if it is present.
		getMenuInflater().inflate(R.menu.activity_main, menu);
		return true;
	}

}

public class RemoteService extends Service {
	@Override
	public void onCreate() {
		System.out.println("远程服务被创建了。。。");
		super.onCreate();
	}
	@Override
	public void onDestroy() {
		System.out.println("远程服务被销毁了。");
		super.onDestroy();
	}

	@Override
	public IBinder onBind(Intent intent) {
		return new MiddlePerson();
	}
	private void methodInService(){
		System.out.println("我是远程服务的方法，我被调用了。。。。");
	}
	//1.创建一个中间人  远程服务继承的是ipc的一个实现类
	private class MiddlePerson extends IMiddlePerson.Stub{
		@Override
		public void callMethodInService() {
			methodInService();
		}
	}
}

.aidl文件

interface IMiddlePerson {
	/**
	 * 调用服务里面的方法
	 */
	 void callMethodInService();
}

在看看绑定服务端的代码.

public class MainActivity extends Activity {
	private MyConn conn;
	private IMiddlePerson iMp;
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
	}

	/**
	 * 绑定远程服务
	 * @param view
	 */
	public void bind(View view){
		Intent intent = new Intent();
		intent.setAction("com.itheima.remoteservice");
		conn = new MyConn();
		bindService(intent, conn, BIND_AUTO_CREATE);
	}
	
	private class MyConn implements ServiceConnection{
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			iMp = IMiddlePerson.Stub.asInterface(service);
		}
		@Override
		public void onServiceDisconnected(ComponentName name) {
			
		}
	}
	
	public void call(View view){
		try {
			iMp.callMethodInService();
		} catch (RemoteException e) {
			e.printStackTrace();
		}
	}
	@Override
	protected void onDestroy() {
		unbindService(conn);
		super.onDestroy();
	}
}

.aidl文件

interface IMiddlePerson {
	/**
	 * 调用服务里面的方法
	 */
	 void callMethodInService();
}

界面如下：

单击后，后台输出如下：

所以实现了远程调用的逻辑业务功能。

可以发现远程调用和bind调用是一样的，只能是bind调用来实现，但是必须通过进程来实现。

对上面的本地服务和远程服务bind绑定做一个小结：

远程服务：调用者和服务在不同的工程代码里面。

本地服务：调用者和服务在同一个工程代码里面。

每一个应用程序都是运行在自己独立的进程里面的。

进程操作系统分配内存空间的一个单位。进程的数据都是独立的。独立的内存空间。

aidl：android interface definition language 安卓接口定义语言

aidl文件都是公有的，没有访问权限修饰符

IPC： inter process communication 进程间通讯

绑定本地服务调用方法的步骤：

1.在服务的内部创建一个内部类提供一个方法，可以间接调用服务的方法

private class MiddlePerson extends Binder implements IMiddlePerson{}

2.实现服务的onbind方法，返回的就是中间人 MiddlePerson

3.在activity 绑定服务。bindService();

4.在服务成功绑定的时候会执行一个方法 onServiceConnected 传递过来一个 IBinder对象

5.强制类型转化调用接口里面的方法。

绑定远程服务调用方法的步骤：

1.在服务的内部创建一个内部类提供一个方法，可以间接调用服务的方法

2.把暴露的接口文件的扩展名改为aidl文件去掉访问修饰符 public

private class MiddlePerson extends IMiddlePerson.Stub{} IPC的子类

3.实现服务的onbind方法，返回的就是中间人 IMiddlePerson

4.在activity 绑定服务。bindService();

5.在服务成功绑定的时候会执行一个方法 onServiceConnected 传递过来一个 IBinder对象

6.IMiddlePerson.Stub.asInterface(binder) 调用接口里面的方法。

下面通过一个调用远程服务运用混合模式开启服务案例

需求：支付宝对外提供服务，实现支付等功能。服务必须不能停止，要在后台长期运行。【所以必须柔和两种服务绑定的方式】

两个工程的包结构：

对于支付宝里面提供的服务：

public class SafePayService extends Service {

	@Override
	public IBinder onBind(Intent intent) {
		System.out.println("服务被绑定 onbind");
		return new MyBinder();
	}
	/**
	 * 安全支付的方法
	 */
	private boolean pay(long time,String pwd,double money){
		if("123".equals(pwd)){
			return true;
		}else{
			return false;
		}
	}
	
	private class MyBinder extends ISafePay.Stub{
		/**
		 * 调用安全支付的逻辑
		 */
		@Override
		public boolean callPay(long time, String pwd, double money)
				throws RemoteException {
			return pay(time, pwd, money);
		}
		
	}
	
	@Override
	public void onCreate() {
		System.out.println("oncreate支付宝服务被创建，一直在后台运行，检查手机的安全状态");
		super.onCreate();
	}
	@Override
	public int onStartCommand(Intent intent, int flags, int startId) {
		System.out.println("服务onstart");
		return super.onStartCommand(intent, flags, startId);
	}
	
	@Override
	public boolean onUnbind(Intent intent) {
		System.out.println("onunbind");
		return super.onUnbind(intent);

	}
	@Override
	public void onDestroy() {
		System.out.println("ondestory支付宝服务被销毁");
		super.onDestroy();
	}
	
}

.aidl的接口：

interface ISafePay{
	boolean callPay(long time,String pwd,double money);
}

在另外一个项目中调用如下：

public class MainActivity extends Activity {
	private ISafePay iSafePay;
	private MyConn conn;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
//		Intent intent = new Intent();
//		intent.setAction("com.itheima.alipay");
//		startService(intent);
		//保证服务长期后台运行。
	
	}
	
	public void start(View view){
		Intent intent = new Intent();
		intent.setAction("com.itheima.alipay");
		startService(intent);
	}
	
	public void stop(View view){
		Intent intent = new Intent();
		intent.setAction("com.itheima.alipay");
		stopService(intent);
	}
	public void bind(View view){
		Intent intent = new Intent();
		intent.setAction("com.itheima.alipay");
		conn = new MyConn();
		bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
	}
	public void unbind(View view){
		unbindService(conn);
	}
	
	
	
	public void click(View view){
		Intent intent = new Intent();
		intent.setAction("com.itheima.alipay");
		conn = new MyConn();
		bindService(intent, conn, BIND_AUTO_CREATE);//异步的操作
		//绑定服务调用服务的方法。
		
	}
	
	private class MyConn implements ServiceConnection{
		@Override
		public void onServiceConnected(ComponentName name, IBinder service) {
			iSafePay = ISafePay.Stub.asInterface(service);
			try {
				boolean result = iSafePay.callPay(System.currentTimeMillis(), "123", 3.52f);
				if(result){
					Toast.makeText(getApplicationContext(), "支付成功，获取大炮弹", 0).show();
				}else{
					Toast.makeText(getApplicationContext(), "支付失败，请重试", 0).show();
				}
//				unbindService(conn);
//				conn = null;
			} catch (RemoteException e) {
				e.printStackTrace();
			}
		}

		@Override
		public void onServiceDisconnected(ComponentName name) {
			
		}
	}
}

实现的界面：

必须按顺序依次：

混合调用的服务的生命周期：

服务长期后台运行，又想调用服务的方法：

1.start方式开启服务（保证服务长期后台运行）

2.bind方式绑定服务（保证调用服务的方法）

3.unbind解除绑定服务

4.stopService停止服务。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航