DDL起名、DML和DCL的精通

  学习android开发已经四七个月,由于类别中级职称责的来由平昔从未接触过Service的实在项目,前几天再也学二次Service用法。

一、DDL

  问题:

 1、DDL的概述

    作为四大组件,为啥必要Service?

      DDL(Data Definition Language
数据定义语言)用于操作对象和对象的性质,那种对象包含数据库本人,以及数据库对象,像:表、视图等等,DDL对那么些目的和属性的田管和概念具体表未来Create、Drop和Alter上。特别注意:DDL操作的“对象”的定义,”对象“包罗对象及对象的性质,而且对象最小也比记录大个层次。以表举例:Create创设数据表,Alter能够变动该表的字段,Drop能够去除那么些表,从那里大家能够看出,DDL所站的万丈,他不会对现实的数额进行操作。

    它与Thread又有啥区别?

 

    具体怎么用?

② 、DDL的要害语句(操作)

    如何兑现与Activity之间的通讯?

      Create语句:能够创立数据库和数据库的一部分目的。

一、Service 介绍

从官网中,大家得以观望那般一句:

Most confusion about the Service class actually revolves around what
it is not:

  • A Service is not a separate process. The Service object itself
    does not imply it is running in its own process; unless otherwise
    specified, it runs in the same process as the application it is
    part of.
  • A Service is not a thread. It is not a means itself to do work off
    of the main thread (to avoid Application Not Responding errors).

Thus a Service itself is actually very simple, providing two main
features:

  • A facility for the application to tell the system about something
    it wants to be doing in the background (even when the user is not
    directly interacting with the application). This corresponds to
    calls to Context.startService(), which ask the system to schedule
    work for the service, to be run until the service or someone else
    explicitly stop it.
  • A facility for an application to expose some of its functionality
    to other applications. This corresponds to calls
    to Context.bindService(), which allows a long-standing connection
    to be made to the service in order to interact with it.

  简而言之,Service不是1个独立的经过,除非它被优异钦点,不然它也是我们应用程序的一片段,它要求依靠于创立服务时所在的应用程序。同时Service也不是一个线程,它实质上是在主线程工作的,所以无法在Service中处理耗费时间的操作,不然就会油然则生A奥迪Q7N现象,假若要处理耗费时间的操作,能够新开叁个子线程,单独处理。

  更进一步讲,Service是
Android中完成程序后台运行的化解方案,它十二分适合用于去实践那2个不需求和用户交互而且还供给长期运行的任务。服务的运营不重视于别的用户界面,尽管当程序被切换来后台,或许用户打开了此外2个应用程序,服务还能够保持寻常运维。

Service有二种运行格局,一种是通过startService()艺术,一种是透过bindService()方法,那那二种具体有怎么着分别呢,大家能够看下它们的生命周期来看到端倪。

     
Drop语句:能够去除数据表、索引、触发程序、条件约束以及数据表的权柄等。

1.1 Service 生命周期 及三种状态

起名 1

  Service 分为二种工作情形: 一种是 运转状态用于实践后台计算,另一种是
绑定状态用于和任何零件和瑟维斯进行交互。要求注意的是那两种情状的Service是足以存活的,即Service既能够处于绑定状态和开行状态。

startService()运维的生命周期:

  当大家率先次利用startService运维二个劳务时,系统实例化叁个Service实例,然后挨家挨户调用onCreate()和onStartCommand()方法,然后运转,要求注意的是,再度利用startService方法时,不会在开创四个新的劳务对象了,但要么会重复实施onStartCommand()方法,设若我们想要停掉三个劳务,能够用stopService方法,此时,onDestroy()方法就会被调用,不管后边使用了有个别次的startService,stopService方法调用2回,就可停掉服务。

 自定义一个 MyService继承自Service 

起名 2起名 3

public class MyService extends Service {

    public static final String TAG = "MyService";

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate() executed");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand() executed");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy() executed");
    }

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

}

View Code

当全国startService()运维贰个Service时

Intent startIntent = new Intent(this, MyService.class);  
startService(startIntent);  

log消息如下:

起名 4

再次启航Service时: 

起名 5

调用stopService()时,瑟维斯就会被终止。

Intent stopIntent = new Intent(this, MyService.class);  
stopService(stopIntent);  

那种艺术Service和Activity的涉嫌并十分的小,只是Activity通知了Service一下:“你能够运转了。”然后Service就去忙本人的事务了

bindService()运行的生命周期:

  当调用者第一遍选用bindService绑定叁个劳动时,系统会实例化3个Service实例,并1回调用其onCreate()方法和onBind()方法,然后调用者就足以和劳动举行相互了,此后,假如重新利用bindService绑定服务,系统不会成立新的Service实例,也不会再调用onBind方法;假如咱们须要解决与这几个服务的绑定,可利用unbindService方法,此时onUnbind方法和onDestroy方法会被调用。

自定义Service;

public class MyService extends Service {

    public static final String TAG = "MyService";

    private MyBinder mBinder = new MyBinder();

    @Override
    public void onCreate() {
        super.onCreate();
        Log.d(TAG, "onCreate() executed");
    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "onStartCommand() executed");
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy() executed");
    }

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

    class MyBinder extends Binder {

        public void startDownload() {
            Log.d("TAG", "startDownload() executed");
            // 执行具体的下载任务
        }

    }

}

  那里大家新增了五个MyBinder类继承自Binder类,然后在MyBinder中添加了二个startDownload()方法用于在后台执行下载职分,当然那里并不是真的地去下载有个别东西,只是做个测试,所以startDownload()方法只是打字与印刷了一行日志。

在MainActivity中拉开和倒闭Service:

public class MainActivity extends Activity implements OnClickListener {

    private Button startService;

    private Button stopService;

    private Button bindService;

    private Button unbindService;

    private MyService.MyBinder myBinder;

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myBinder = (MyService.MyBinder) service;
            myBinder.startDownload();
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        startService = (Button) findViewById(R.id.start_service);
        stopService = (Button) findViewById(R.id.stop_service);
        bindService = (Button) findViewById(R.id.bind_service);
        unbindService = (Button) findViewById(R.id.unbind_service);
        startService.setOnClickListener(this);
        stopService.setOnClickListener(this);
        bindService.setOnClickListener(this);
        unbindService.setOnClickListener(this);
    }

    @Override
    public void onClick(View v) {
        switch (v.getId()) {
        case R.id.start_service:
            Intent startIntent = new Intent(this, MyService.class);
            startService(startIntent);
            break;
        case R.id.stop_service:
            Intent stopIntent = new Intent(this, MyService.class);
            stopService(stopIntent);
            break;
        case R.id.bind_service:
            Intent bindIntent = new Intent(this, MyService.class);
            bindService(bindIntent, connection, BIND_AUTO_CREATE);
            break;
        case R.id.unbind_service:
            unbindService(connection);
            break;
        default:
            break;
        }
    }

}

  能够见见,那里大家首先创造了3个ServiceConnection的匿名类,在中间重写了onServiceConnected()方法和onServiceDisconnected()方法,那四个章程分别会在Activity与瑟维斯建立关系和解除关系的时候调用。在onServiceConnected()方法中,大家又通过向下转型取得了MyBinder的实例,有了这么些实例,Activity和Service之间的关系就变得相当严密了。现在大家得以在Activity中依照现实的气象来调用MyBinder中的任何public方法,即完成了Activity指挥Service干什么Service就去干什么的意义。 

      Alter语句:修改数据表定义及品质。

1.2 同时startService和binderService

  如果大家既点击了StartService按钮,又点击了Bind
Service按钮会怎样啊?那几个时候你会发觉,不管你是独立点击Stop
Service按钮照旧Unbind
Service按钮,Service都不会被销毁,须要将三个按钮都点击一下,Service才会被灭绝。也等于说,点击Stop
Service按钮只会让Service甘休,点击Unbind
Service按钮只会让Service和Activity解除关系,1个Service必供给在既没有和任何Activity关联又处理结束状态的时候才会被销毁。

  先点击一下Start Service按钮,再点击一下Bind
Service按钮,那样就将瑟维斯运营起来,并和Activity建立了事关。然后点击Stop
瑟维斯按钮后Service并不会销毁,再点击一下Unbind
Service按钮,Service就会销毁了,打印日志如下所示:

起名 6

 

总结:

  那三个运维格局的例外,导致生命周期也不如。startService与调用者没有必然的关系,即调用者截至了自个儿的生命周期,只要没有利用stopService方法停止那些服务,服务仍会运作。而bindService需求有个寄宿的对象,就也正是bind到有个别宿主中去,什么人绑定了,何人就要肩负,负责它的生命周期,从开首到停止,借使宿主本人的生命周期甘休了,bindService方式即将先把服务给销毁掉。

  值得注意的一些是,假诺调用者首先是先用startService方式运维服务,然后再用bindService方式绑定有些服务来说,一定要先用unbindService格局解绑,然后才用stopService方式销毁服务指标,不然的话,仅仅只是stopService是不够的,没解绑的靶子仍旧在的,就简单导致内部存款和储蓄器败露了。

  我们理应一味记得在Service的onDestroy()方法里去清理掉那多少个不再行使的能源,幸免在Service被灭绝后还会有部分不再动用的目的仍占据着内部存款和储蓄器。

 

 

贰 、Service 与 Thread 之间的关系

  瑟维斯与Thread那四个是尚未怎么关系的。因为大家领悟瑟维斯是运营在UI线程中,那么当须要耗时操作的时候,就须求Thread帮忙,不是说Service因为是在后台运营,就跟Thread等同了。Thread是用来开启一个子线程,在那里去实施一些耗费时间操作就不会卡住主线程的周转。而Service大家最初知道的时候,总会以为它是用来拍卖部分后台任务的,一些相比较耗费时间的操作也足以放在此处运营,那就会令人发生模糊了。

  Android的后台正是指,它的运行是截然不注重UI的。就算Activity被销毁,或然程序被关闭,只要经过还在,Service就足以持续运转。比如说有的应用程序,始终必要与服务器之间始终维持着心跳连接,就能够应用Service来实现。

  大家得以在Service中再创制贰个子线程,然后在那边去处理耗时逻辑就没难点。既然在Service里要创制一个子线程,那干什么不间接在Activity里创设呢?那是因为Activity很难对Thread实行控制,当Activity被销毁之后,就不曾别的其余的方法能够再另行取获得此前创立的子线程的实例。而且在1个Activity中开创的子线程,另3个Activity无法对其开始展览操作。但是Service就不相同了,全部的Activity都能够与Service举行关联,然后能够很有益地操作当中的法门,即便Activity被灭绝了,之后即便重新与Service建立关系,就又能够获取到原来的Service中Binder的实例。因而,使用Service来处理后台任务,Activity就足以放心地finish,完全不必要担心无法对后台职务举办支配的景况。

 当供给在几个Service中开创贰个子线程时,能够由此如下实现:

@Override
public int onStartCommand(Intent intent, int flags, int startId) {
    new Thread(new Runnable() {
        @Override
        public void run() {
            // 开始执行后台任务
        }
    }).start();
    return super.onStartCommand(intent, flags, startId);
}

class MyBinder extends Binder {

    public void startDownload() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 执行具体的下载任务
            }
        }).start();
    }

}

叁 、 DDL的操作对象(表)

三 、 创立前台Service

  Service差不多都是在后台运维的,一直以来它都以名不见经传地做着劳动的行事。可是Service的系统优先级如故比较低的,当系统出现内部存款和储蓄器不足意况时,就有或许会回收掉正在后台运维的Service。如若您希望Service能够直接保持运行情况,而不会出于系统内存不足的由来促成被回收,就能够设想动用前台Service。前台Service和平常Service最大的界别就在于,它会直接有二个正在运营的图标在系统的情形栏显示,下拉事态栏后能够观望越来越详细的消息,十三分相近于公告的功力。当然有时候你也可能非但是为着防备Service被回收才使用前台瑟维斯,有个别项目由于独特的须要会供给必须利用前台Service,比如说墨迹天气,它的Service在后台更新天气数据的同时,还会在系统状态栏向来呈现当前气象的音讯。

  那么大家就来看一下怎么才能成立3个前台Service吧,其实并不复杂,修改My瑟维斯中的代码,如下所示:

public class MyService extends Service {

    public static final String TAG = "MyService";

    private MyBinder mBinder = new MyBinder();

    @Override
    public void onCreate() {
        super.onCreate();
        Notification notification = new Notification(R.drawable.ic_launcher,
                "有通知到来", System.currentTimeMillis());
        Intent notificationIntent = new Intent(this, MainActivity.class);
        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
                notificationIntent, 0);
        notification.setLatestEventInfo(this, "这是通知的标题", "这是通知的内容",
                pendingIntent);
        startForeground(1, notification);
        Log.d(TAG, "onCreate() executed");
    }

    .........

}

  这里只是修改了My瑟维斯中onCreate()方法的代码。能够看出,我们率先创立了3个Notification对象,然后调用了它的setLatest伊夫ntInfo()方法来为公告初叶化布局和数目,并在此地设置了点击文告后就打开MainActivity。然后调用startForeground()方法就能够让MyService变成2个前台Service,并会将通告的图样展现出来。

      1)、表的概念

肆 、远程Service(开辟1个新进度)

 将1个Service放到独门的历程中去实践:

  <service  
        android:name="com.example.servicetest.MyService"  
        android:process=":remote" >  
    </service>  

  此时,可以通过startService去开启那一个Service(能够在那么些Service中处理耗费时间的操作,而不影响主线程的执行,因为它在另2个独立的经过中)。但是当我们在MainAcitivity中去bindService时,程序会崩溃(因为MainActivity在主进度中而瑟维斯运维在长距离的长河中,让MainActivity和MyService建立关联会让程序崩溃)。

  那么哪些关联1个Activity与Service,那时候供给用AIDL来经过间通讯(IPC)

 

  AIDL(Android Interface
Definition
Language)是Android接口定义语言的意味,它能够用于让有些Service与几个应用程序组件之间展开跨进程通讯,从而得以完结多少个应用程序共享同二个Service的功能。

           
表的创办正是用来存放数据用的,由于大家存放的数额的不等,所以大家要求定义些数据类型,以方便管理。

4.1 开启service的Server端程序

  上边大家就来一步步地看一下AIDL的用法到底是何等的。首先必要新建贰个AIDL文件,在那些文件中定义好Activity需求与Service进行通讯的方式。新建MyAIDLService.aidl文件,代码如下所示:(点击sync后,会生成MyAIDL瑟维斯.java文件)

package com.example.servicetest;
interface MyAIDLService {
    int plus(int a, int b);
    String toUpperCase(String str);
}

下一场修改MyService中的代码,在里头达成大家正好定义好的MyAIDLService接口,如下所示:

public class MyService extends Service {

    ......

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

    MyAIDLService.Stub mBinder = new Stub() {

        @Override
        public String toUpperCase(String str) throws RemoteException {
            if (str != null) {
                return str.toUpperCase();
            }
            return null;
        }

        @Override
        public int plus(int a, int b) throws RemoteException {
            return a + b;
        }
    };

}

  那里首先对MyAIDLService.Stub进行了落到实处,重写里了toUpperCase()和plus()那多个方法。那五个法子的法力分别是将多个字符串全体转换到大写格式,以及将三个传入的平头进行相加。然后在onBind()方法准将MyAIDLService.Stub的兑现再次回到。这里怎么能够这么写啊?因为Stub其实正是Binder的子类,所以在onBind()方法中得以一向回到Stub的落到实处。

public class MainActivity extends Activity implements OnClickListener {

    private Button startService;

    private Button stopService;

    private Button bindService;

    private Button unbindService;

    private MyAIDLService myAIDLService;

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myAIDLService = MyAIDLService.Stub.asInterface(service);
            try {
                int result = myAIDLService.plus(3, 5);
                String upperStr = myAIDLService.toUpperCase("hello world");
                Log.d("TAG", "result is " + result);
                Log.d("TAG", "upperStr is " + upperStr);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

    ......

}

  可以看来,那里首先采纳了MyAIDLService.Stub.asInterface()方法将盛传的IBinder对象传换来了MyAIDL瑟维斯对象,接下去就足以调用在MyAIDLService.aidl文件中定义的保有接口了。那里大家第2调用了plus()方法,并传到了3和5看成参数,然后又调用了toUpperCase()方法,并传播hello
world字符串作为参数,最后将调用方法的回到结果打字与印刷出来。

同理可得,大家真的已经打响促成跨进度通讯了,在3个历程中访问到了此外3个进度中的方法。

 

  可是你也得以看到,近日的跨进度通讯其实并从未什么样实质上的效能,因为那只是在四个Activity里调用了同一个应用程序的Service里的法门。而跨进程通讯的真正含义是为了让贰个应用程序去做客另1个应用程序中的Service,以达成共享Service的职能。那么上面大家自然要读书一下,如何才能在其余的应用程序中调用到MyService里的不二法门。

 

倘使想要让Activity与Service之间确立关联,必要调用bindService()方法,并将Intent作为参数字传送递进去,在Intent里钦定好要绑定的Service,示例代码如下:

Intent bindIntent = new Intent(this, MyService.class);  
bindService(bindIntent, connection, BIND_AUTO_CREATE);  

注册Service(让别的程序可以透过隐式方法访问该Service)

<service  
        android:name="com.example.servicetest.MyService"  
        android:process=":remote" >  
        <intent-filter>  
            <action android:name="com.example.servicetest.MyAIDLService"/>  
        </intent-filter>  
    </service>  

注:android 5.0 之后隐式方法访问Service须要: 

  Intent intent = new
Intent(“com.example.servicetest.MyAIDLService”).setPackage(com.example.servicetest);

到此,Server端的
service就定义好了,他得以在该server端的顺序中运作,其余程序也得以访问该Service

      2)、表的本性

4.2 访问Service的Client端程序

下一场创立八个新的Android项目,起名为ClientTest,大家就尝试在这一个程序中国远洋运输总公司程调用MyService中的方法。

 

ClientTest中的Activity就算想要和MyService建立关系其实也简单,首先须求将MyAIDLService.aidl文件从ServiceTest项目中拷贝过来,注意要将原有的包路径一起拷贝过来,完成后项目标结构如下图所示:

起名 7

接下去打开或新建MainActivity,在当中参预和MyService建立关系的代码,如下所示:

public class MainActivity extends Activity {

    private MyAIDLService myAIDLService;

    private ServiceConnection connection = new ServiceConnection() {

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            myAIDLService = MyAIDLService.Stub.asInterface(service);
            try {
                int result = myAIDLService.plus(50, 50);
                String upperStr = myAIDLService.toUpperCase("comes from ClientTest");
                Log.d("TAG", "result is " + result);
                Log.d("TAG", "upperStr is " + upperStr);
            } catch (RemoteException e) {
                e.printStackTrace();
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button bindService = (Button) findViewById(R.id.bind_service);
        bindService.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                Intent intent = new Intent("com.example.servicetest.MyAIDLService");
                bindService(intent, connection, BIND_AUTO_CREATE);
            }
        });
    }

}

那有的代码我们肯定会越发眼熟吧?没错,那和在ServiceTest的MainActivity中的代码大致是完全相同的,只是在让Activity和Service建立关联的时候我们应用了隐式Intent,将Intent的action钦赐成了com.example.servicetest.MyAIDLService。

 这样我们跨进度跨app的通讯就完了了。

 

参报考博士大学生客:

http://www.cnblogs.com/cr330326/p/5741464.html

http://blog.csdn.net/guolin\_blog/article/details/11952435/

http://blog.csdn.net/guolin\_blog/article/details/9797169

 

package com.example.servicetest;interface MyAIDLService {int plus(int a,
int b);String toUpperCase(String str);}

           
主键属性:主键正是主键约束,只不过起的名字不一致了,主键的起名偏向于虚的(正是讲述描述那件事),主键约束起名偏向于实得(就是讲述操作的执行),描述的都以同等件事,主键约束便是表中的贰天品质;在多个表中最多能够有二个主键;三个主键能够定义在三个或几个字段;主键使3个或多少个字段的值必须唯一且不为空,那样做能够透过该字段或该组字段中的值唯一的代表一条记下。

           
唯一属性:三个表中只好有二个主键属性,为了方表用户,提出唯一约束;唯一约束能够定义在1个或七个字段上;唯一约束使该字段或该组字段中的值唯一,能够为空,但是,无法再度。

           
外键属性:又叫外键,又叫外键约束,跟主键和主键约束的涉及是一律的;外键约束针对的四个表,假诺表A的主关键字是表B中的字段,则该字段称为表B的外键,表A称为主表,表B称为从表,但要注意,供给求计算机要明白您是那种涉及。
            核查、Null和缺省属性:核对属性又叫核对约束,Null属性又叫Null约束,缺省属性又叫缺省约束;这么些名称是讲述一件事,描述一种情景,那件事或那张意况大家当然能够人工的那样特意做(输入数据是专注就行),但是,他们的原意是贯彻自动化,也正是让电脑做那件事。

 

二、DML

1、DML的概述

     DML(Data Manipulation Language
数据操控语言)用于操作数据库对象中带有的数据,也正是说操作的单位是记录。

 

贰 、DML的首要语句(操作)

     Insert语句:向数据表张插入一条记下。

   
 Delete语句:删除数据表中的一条或多条记下,也能够去除数据表中的保有记录,但是,它的操作对象仍是记录。

     Update语句:用于修改已存在表中的笔录的始末。

 

三 、DML的操作对象——记录

     1)、注意当咱们对记录进行Insert、Delete和Update操作的时候,一定要注意,一定要明白DDL对其的有个别操作。

 

三、DCL

1、DCL的概述

     DCL(Data Control Language
数据控制语句)的操作是数据库对象的权杖,那个操作的规定使数码进一步的安全。

 

贰 、DCL的严重性语句(操作)

   
 格兰特语句:允许对象的创制者给某用户或某组或具有用户(PUBLIC)某个特定的权柄。

     Revoke语句:能够舍弃某用户或某组或持有用户访问权限

 

叁 、DCL的操作对象(用户)

     此时的用户指的是数据库用户。

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图