精华内容
下载资源
问答
  • 相信大多数朋友对Service这个名词都不会陌生,没错,一个老练的Android程序员如果连Service都没听说过的话,那确实也太逊了。Service作为Android四大组件之一,在每一个应用程序中都扮演着非常重要的角色。它主要...

    转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/11952435


    相信大多数朋友对Service这个名词都不会陌生,没错,一个老练的Android程序员如果连Service都没听说过的话,那确实也太逊了。Service作为Android四大组件之一,在每一个应用程序中都扮演着非常重要的角色。它主要用于在后台处理一些耗时的逻辑,或者去执行某些需要长期运行的任务。必要的时候我们甚至可以在程序退出的情况下,让Service在后台继续保持运行状态。


    不过,虽然Service几乎被每一个Android程序员所熟知,但并不是每个人都已经将Service的各个知识点都掌握得非常透彻。那么今天我就将带着大家对Service进行一次全面、深入的探究,希望每个人在读完本篇文章后都能对Service有更深一层的理解。


    Service的基本用法


    关于Service最基本的用法自然就是如何启动一个Service了,启动Service的方法和启动Activity很类似,都需要借助Intent来实现,下面我们就通过一个具体的例子来看一下。

    新建一个Android项目,项目名就叫ServiceTest,这里我选择使用4.0的API。


    然后新建一个MyService继承自Service,并重写父类的onCreate()、onStartCommand()和onDestroy()方法,如下所示:

    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;
    	}
    
    }

    可以看到,我们只是在onCreate()、onStartCommand()和onDestroy()方法中分别打印了一句话,并没有进行其它任何的操作。


    然后打开或新建activity_main.xml作为程序的主布局文件,代码如下所示:

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical" >
    
        <Button
            android:id="@+id/start_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Start Service" />
    
        <Button
            android:id="@+id/stop_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Stop Service" />
    
    </LinearLayout>

    我们在布局文件中加入了两个按钮,一个用于启动Service,一个用于停止Service。


    然后打开或新建MainActivity作为程序的主Activity,在里面加入启动Service和停止Service的逻辑,代码如下所示:

    public class MainActivity extends Activity implements OnClickListener {
    
    	private Button startService;
    
    	private Button stopService;
    
    	@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);
    		startService.setOnClickListener(this);
    		stopService.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;
    		default:
    			break;
    		}
    	}
    
    }
    可以看到,在Start Service按钮的点击事件里,我们构建出了一个Intent对象,并调用startService()方法来启动MyService。然后在Stop Serivce按钮的点击事件里,我们同样构建出了一个Intent对象,并调用stopService()方法来停止MyService。代码的逻辑非常简单,相信不需要我再多做解释了吧。


    另外需要注意,项目中的每一个Service都必须在AndroidManifest.xml中注册才行,所以还需要编辑AndroidManifest.xml文件,代码如下所示:

    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
        package="com.example.servicetest"
        android:versionCode="1"
        android:versionName="1.0" >
    
        <uses-sdk
            android:minSdkVersion="14"
            android:targetSdkVersion="17" />
    
        <application
            android:allowBackup="true"
            android:icon="@drawable/ic_launcher"
            android:label="@string/app_name"
            android:theme="@style/AppTheme" >
            
    	……
    
            <service android:name="com.example.servicetest.MyService" >
            </service>
        </application>
    
    </manifest>

    这样的话,一个简单的带有Service功能的程序就写好了,现在我们将程序运行起来,并点击一下Start Service按钮,可以看到LogCat的打印日志如下:



    也就是说,当启动一个Service的时候,会调用该Service中的onCreate()和onStartCommand()方法。


    那么如果我再点击一次Start Service按钮呢?这个时候的打印日志如下:




    可以看到,这次只有onStartCommand()方法执行了,onCreate()方法并没有执行,为什么会这样呢?这是由于onCreate()方法只会在Service第一次被创建的时候调用,如果当前Service已经被创建过了,不管怎样调用startService()方法,onCreate()方法都不会再执行。因此你可以再多点击几次Start Service按钮试一次,每次都只会有onStartCommand()方法中的打印日志。


    我们还可以到手机的应用程序管理界面来检查一下MyService是不是正在运行,如下图所示:



    恩,MyService确实是正在运行的,即使它的内部并没有执行任何的逻辑。


    回到ServiceTest程序,然后点击一下Stop Service按钮就可以将MyService停止掉了。


    Service和Activity通信


    上面我们学习了Service的基本用法,启动Service之后,就可以在onCreate()或onStartCommand()方法里去执行一些具体的逻辑了。不过这样的话Service和Activity的关系并不大,只是Activity通知了Service一下:“你可以启动了。”然后Service就去忙自己的事情了。那么有没有什么办法能让它们俩的关联更多一些呢?比如说在Activity中可以指定让Service去执行什么任务。当然可以,只需要让Activity和Service建立关联就好了。


    观察MyService中的代码,你会发现一直有一个onBind()方法我们都没有使用到,这个方法其实就是用于和Activity建立关联的,修改MyService中的代码,如下所示:

    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()方法只是打印了一行日志。


    然后修改activity_main.xml中的代码,在布局文件中添加用于绑定Service和取消绑定Service的按钮:

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical" >
    
        <Button
            android:id="@+id/start_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Start Service" />
    
        <Button
            android:id="@+id/stop_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Stop Service" />
    
        <Button
            android:id="@+id/bind_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Bind Service" />
        
        <Button 
            android:id="@+id/unbind_service"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Unbind Service"
            />
        
    </LinearLayout>
    接下来再修改MainActivity中的代码,让MainActivity和MyService之间建立关联,代码如下所示:
    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;
    		}
    	}
    
    }

    可以看到,这里我们首先创建了一个ServiceConnection的匿名类,在里面重写了onServiceConnected()方法和onServiceDisconnected()方法,这两个方法分别会在Activity与Service建立关联和解除关联的时候调用。在onServiceConnected()方法中,我们又通过向下转型得到了MyBinder的实例,有了这个实例,Activity和Service之间的关系就变得非常紧密了。现在我们可以在Activity中根据具体的场景来调用MyBinder中的任何public方法,即实现了Activity指挥Service干什么Service就去干什么的功能。


    当然,现在Activity和Service其实还没关联起来了呢,这个功能是在Bind Service按钮的点击事件里完成的。可以看到,这里我们仍然是构建出了一个Intent对象,然后调用bindService()方法将Activity和Service进行绑定。bindService()方法接收三个参数,第一个参数就是刚刚构建出的Intent对象,第二个参数是前面创建出的ServiceConnection的实例,第三个参数是一个标志位,这里传入BIND_AUTO_CREATE表示在Activity和Service建立关联后自动创建Service,这会使得MyService中的onCreate()方法得到执行,但onStartCommand()方法不会执行。


    然后如何我们想解除Activity和Service之间的关联怎么办呢?调用一下unbindService()方法就可以了,这也是Unbind Service按钮的点击事件里实现的逻辑。


    现在让我们重新运行一下程序吧,在MainActivity中点击一下Bind Service按钮,LogCat里的打印日志如下图所示:




    另外需要注意,任何一个Service在整个应用程序范围内都是通用的,即MyService不仅可以和MainActivity建立关联,还可以和任何一个Activity建立关联,而且在建立关联时它们都可以获取到相同的MyBinder实例。


    如何销毁Service


    在Service的基本用法这一部分,我们介绍了销毁Service最简单的一种情况,点击Start Service按钮启动Service,再点击Stop Service按钮停止Service,这样MyService就被销毁了,可以看到打印日志如下所示:



    那么如果我们是点击的Bind Service按钮呢?由于在绑定Service的时候指定的标志位是BIND_AUTO_CREATE,说明点击Bind Service按钮的时候Service也会被创建,这时应该怎么销毁Service呢?其实也很简单,点击一下Unbind Service按钮,将Activity和Service的关联解除就可以了。


    先点击一下Bind Service按钮,再点击一下Unbind Service按钮,打印日志如下所示:



    以上这两种销毁的方式都很好理解。那么如果我们既点击了Start Service按钮,又点击了Bind Service按钮会怎么样呢?这个时候你会发现,不管你是单独点击Stop Service按钮还是Unbind Service按钮,Service都不会被销毁,必要将两个按钮都点击一下,Service才会被销毁。也就是说,点击Stop Service按钮只会让Service停止,点击Unbind Service按钮只会让Service和Activity解除关联,一个Service必须要在既没有和任何Activity关联又处理停止状态的时候才会被销毁。


    为了证实一下,我们在Stop Service和Unbind Service按钮的点击事件里面加入一行打印日志:

    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:
    		Log.d("MyService", "click Stop Service button");
    		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:
    		Log.d("MyService", "click Unbind Service button");
    		unbindService(connection);
    		break;
    	default:
    		break;
    	}
    }

    然后重新运行程序,先点击一下Start Service按钮,再点击一下Bind Service按钮,这样就将Service启动起来,并和Activity建立了关联。然后点击Stop Service按钮后Service并不会销毁,再点击一下Unbind Service按钮,Service就会销毁了,打印日志如下所示:



    我们应该始终记得在Service的onDestroy()方法里去清理掉那些不再使用的资源,防止在Service被销毁后还会有一些不再使用的对象仍占用着内存。


    Service和Thread的关系


    不少Android初学者都可能会有这样的疑惑,Service和Thread到底有什么关系呢?什么时候应该用Service,什么时候又应该用Thread?答案可能会有点让你吃惊,因为Service和Thread之间没有任何关系!


    之所以有不少人会把它们联系起来,主要就是因为Service的后台概念。Thread我们大家都知道,是用于开启一个子线程,在这里去执行一些耗时操作就不会阻塞主线程的运行。而Service我们最初理解的时候,总会觉得它是用来处理一些后台任务的,一些比较耗时的操作也可以放在这里运行,这就会让人产生混淆了。但是,如果我告诉你Service其实是运行在主线程里的,你还会觉得它和Thread有什么关系吗?让我们看一下这个残酷的事实吧。


    在MainActivity的onCreate()方法里加入一行打印当前线程id的语句:

    Log.d("MyService", "MainActivity thread id is " + Thread.currentThread().getId());
    然后在MyService的onCreate()方法里也加入一行打印当前线程id的语句:
    Log.d("MyService", "MyService thread id is " + Thread.currentThread().getId());

    现在重新运行一下程序,并点击Start Service按钮,会看到如下打印日志:



    可以看到,它们的线程id完全是一样的,由此证实了Service确实是运行在主线程里的,也就是说如果你在Service里编写了非常耗时的代码,程序必定会出现ANR的。


    你可能会惊呼,这不是坑爹么!?那我要Service又有何用呢?其实大家不要把后台和子线程联系在一起就行了,这是两个完全不同的概念。Android的后台就是指,它的运行是完全不依赖UI的。即使Activity被销毁,或者程序被关闭,只要进程还在,Service就可以继续运行。比如说一些应用程序,始终需要与服务器之间始终保持着心跳连接,就可以使用Service来实现。你可能又会问,前面不是刚刚验证过Service是运行在主线程里的么?在这里一直执行着心跳连接,难道就不会阻塞主线程的运行吗?当然会,但是我们可以在Service中再创建一个子线程,然后在这里去处理耗时逻辑就没问题了。


    额,既然在Service里也要创建一个子线程,那为什么不直接在Activity里创建呢?这是因为Activity很难对Thread进行控制,当Activity被销毁之后,就没有任何其它的办法可以再重新获取到之前创建的子线程的实例。而且在一个Activity中创建的子线程,另一个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();
    	}
    
    }

    创建前台Service


    Service几乎都是在后台运行的,一直以来它都是默默地做着辛苦的工作。但是Service的系统优先级还是比较低的,当系统出现内存不足情况时,就有可能会回收掉正在后台运行的Service。如果你希望Service可以一直保持运行状态,而不会由于系统内存不足的原因导致被回收,就可以考虑使用前台Service。前台Service和普通Service最大的区别就在于,它会一直有一个正在运行的图标在系统的状态栏显示,下拉状态栏后可以看到更加详细的信息,非常类似于通知的效果。当然有时候你也可能不仅仅是为了防止Service被回收才使用前台Service,有些项目由于特殊的需求会要求必须使用前台Service,比如说墨迹天气,它的Service在后台更新天气数据的同时,还会在系统状态栏一直显示当前天气的信息,如下图所示:



    那么我们就来看一下如何才能创建一个前台Service吧,其实并不复杂,修改MyService中的代码,如下所示:

    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");
    	}
    
    	.........
    
    }

    这里只是修改了MyService中onCreate()方法的代码。可以看到,我们首先创建了一个Notification对象,然后调用了它的setLatestEventInfo()方法来为通知初始化布局和数据,并在这里设置了点击通知后就打开MainActivity。然后调用startForeground()方法就可以让MyService变成一个前台Service,并会将通知的图片显示出来。


    现在重新运行一下程序,并点击Start Service或Bind Service按钮,MyService就会以前台Service的模式启动了,并且在系统状态栏会弹出一个通栏图标,下拉状态栏后可以看到通知的详细内容,如下图所示。



    好了,由于篇幅的原因,本篇文章就先写到这里。目前我们已经把关于Service的很多重要知识点都梳理完了,下一篇文章会承接这篇文章,介绍Android Service中剩下的一个非常重要且复杂的知识点 —— 远程Service的使用,感兴趣的朋友请继续阅读 Android Service完全解析,关于服务你所需知道的一切(下) 。


    关注我的技术公众号,每天都有优质技术文章推送。关注我的娱乐公众号,工作、学习累了的时候放松一下自己。

    微信扫一扫下方二维码即可关注:

            

    展开全文
  • spring注解@service("service")括号中的service有什么用

    万次阅读 多人点赞 2019-01-09 11:08:53
    service 是有用的相当于 xml配置中得bean id = service 也可以不指定 不指定相当于 bean id = com. service.service 就是这个类的全限定名,表示给当前类命名一个别名,方便注入到其他需要用到的类中;不加的话,默认...

    service  是有用的相当于 xml配置中得bean  id = service  也可以不指定 不指定相当于 bean id =  com. service.service 就是这个类的全限定名,表示给当前类命名一个别名,方便注入到其他需要用到的类中;不加的话,默认别名就是当前类名,但是首字母小写 

     

     

    Spring注解@Component、@Repository、@Service、@Controller区别

    所以,如果 Web 应用程序采用了经典的三层分层结构的话,最好在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释,而用 @Component 对那些比较中立的类进行注释。 

    在一个稍大的项目中,通常会有上百个组件,如果这些组件采用xml的bean定义来配置,显然会增加配置文件的体积,查找以及维护起来也不太方便。 Spring2.5为我们引入了组件自动扫描机制,他可以在类路径底下寻找标注了@Component,@Service,@Controller,@Repository注解的类,并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件时一样的。要使用自动扫描机制,我们需要打开以下配置信息: 
    Java代码 
     

    <?xml version="1.0" encoding="UTF-8" ?> 
    <beansxmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchemainstance"xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans2.5.xsd  
    http://www.springframework.org/schema/context  
    http://www.springframework.org/schema/context/spring-context-2.5.xsd"  > 
      
     <context:component-scan base-package=”com.eric.spring”>   
     </beans>   


    6. 其中base-package为需要扫描的包(含所有子包) @Service用于标注业务层组件,@Controller用于标注控制层组件(如struts中的action),@Repository用于标注数据访问组件,即DAO组件,而@Component泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注。  

    @Service  
    public class VentorServiceImpl implements iVentorService{     
    }   
      
    Repository  
    public class VentorDaoImpl implements iVentorDao {   
    }   
    1. getBean的默认名称是类名(头字母小写),如果想自定义,可以@Service(“aaaaa”)这样来指定,这种bean默认是单例的,  
    2. 如果想改变,可以使用  
    3. @Service(“beanName”)  
    4. @Scope(“prototype”)来改变。可以使用以下方式指定初始化方法和销毁方法(方法名任意):  
    @PostConstruct  
    public void init() {   
     }   
      
     @PreDestroy  
     public void destory() {   
     }   
    


    注入方式: 

    把DAO实现类注入到service实现类中,把service的接口(注意不要是service的实现类)注入到action中,注 

    入时不要new 这个注入的类,因为spring会自动注入,如果手动再new的话会出现错误,然后属性加上 

    @Autowired后不需要getter()和setter()方法,Spring也会自动注入。至于更具体的内容,等对注入的方式更 

    加熟练后会做个完整的例子上来。 

    注解: 

    在 spring的配置文件里面只需要加上<context:annotation-config/>和<context:component-scanbase-package="需要实现注入的类所在包"/>,

    可以使用base-package="*"表示全部的类。   

    < context:component-scan base-package=”com.eric.spring”> 

    其中base-package为需要扫描的包(含所有子包) 

    在接口前面标上@Autowired和@Qualifier注释使得接口可以被容器注入,当接口存在两个实现类的时候必须指定其中一个来注入,

    使用实现类首字母小写的字符串来注入,如: 

        @Autowired      
       
        @Qualifier("chinese")       
       
         private Man man;    
    否则可以省略,只写@Autowired  。 

    @Service服务层组件,用于标注业务层组件,表示定义一个bean,自动根据bean的类名实例化一个首写字母为小写的bean,

    例如Chinese实例化为chinese,如果需要自己改名字则:@Service("你自己改的bean名")。   

    @Controller用于标注控制层组件(如struts中的action) 

    @Repository持久层组件,用于标注数据访问组件,即DAO组件 

    @Component泛指组件,当组件不好归类的时候,我们可以使用这个注解进行标注。 


    @Service 
    public class VentorServiceImpl implements iVentorService { 


    @Repository 
    public class VentorDaoImpl implements iVentorDao { 


    getBean 的默认名称是类名(头字母小写),如果想自定义,可以@Service(“aaaaa”) 这样来指定,这种 

    bean默认是单例的,如果想改变,可以使用@Service(“beanName”)@Scope(“prototype”)来改变。 

    可以使用以下方式指定初始化方法和销毁方法(方法名任意): 

    @PostConstruct 

    public void init() { 



    @PreDestroy 

    public void destory() { 

     

     

     

     

    Spring中@Autowired注解、@Resource注解的区别

    BY ETHAN ON 2011年 06 月 02 日 IN JAVA

    Spring不但支持自己定义的@Autowired注解,还支持几个由JSR-250规范定义的注解,它们分别是@Resource、@PostConstruct以及@PreDestroy。
    @Resource的作用相当于@Autowired,只不过@Autowired按byType自动注入,而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的,分是name和type,Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性,这时将通过反射机制使用byName自动注入策略。
    @Resource装配顺序
    1. 如果同时指定了name和type,则从Spring上下文中找到唯一匹配的bean进行装配,找不到则抛出异常
    2. 如果指定了name,则从上下文中查找名称(id)匹配的bean进行装配,找不到则抛出异常
    3. 如果指定了type,则从上下文中找到类型匹配的唯一bean进行装配,找不到或者找到多个,都会抛出异常
    4. 如果既没有指定name,又没有指定type,则自动按照byName方式进行装配;如果没有匹配,则回退为一个原始类型进行匹配,如果匹配则自动装配;

    @Autowired 与@Resource的区别:

     

    1、 @Autowired与@Resource都可以用来装配bean.都可以写在字段上,或写在setter方法上。

    2、 @Autowired默认按类型装配(这个注解是属业spring的),默认情况下必须要求依赖对象必须存在,如果要允许null值,可以设置它的required属性为false,如:@Autowired(required=false),如果我们想使用名称装配可以结合@Qualifier注解进行使用,如下:

    1

    @Autowired() @Qualifier("baseDao")

    2

    private BaseDao baseDao;

    3、@Resource(这个注解属于J2EE的),默认安装名称进行装配,名称可以通过name属性进行指定,如果没有指定name属性,当注解写在字段上时,默认取字段名进行安装名称查找,如果注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。但是需要注意的是,如果name属性一旦指定,就只会按照名称进行装配。

    1

    @Resource(name="baseDao")

    2

    private BaseDao baseDao;

    推荐使用:@Resource注解在字段上,这样就不用写setter方法了,并且这个注解是属于J2EE的,减少了与spring的耦合。这样代码看起就比较优雅。

    展开全文
  • 2. @Service() 3. @Repository持久层 springvmc采用经典的三层分层控制结构,在持久层,业务层和控制层分别采用@Repository、@Service、@Controller对分层中的类进行注解,而@Component对那些比较中立的类进行...
    
    
    
    

    @Autowired依赖注入源码分析

    1. @Controller控制层

    @Controller用于标记在一个类上,使用它标记的类就是一个SpringMvc Controller对象,分发处理器会扫描使用该注解的类的方法,并检测该方法是否使用了@RequestMapping注解。
    @Controller只是定义了一个控制器类,而使用@RequestMapping注解的方法才是处理请求的处理器。
    @Controller标记在一个类上还不能真正意义上说它就是SpringMvc的控制器,应为这个时候Spring还不认识它,这个时候需要把这个控制器交给Spring来管理。有两种方式可以管理:
    <!--基于注解的装配-->
    <!--方式一-->
    <bean class="com.HelloWorld"/>
    <!--方式二-->
    <!--路径写到controller的上一层-->
    <context:component-scan base-package="com"/>
    

    Action层:

    package com;
    @Controller
    public class HelloWorld{
    	
    	@RequestMapping(value="/showRegUser")
    	public String printHello() {
    		return "hello";
    	}
    
        @Autowried
        private IocSerevce service;
        public void add(){
            service.add();
        }
    }
    
    component-scan默认扫描的注解类型是@Component,不过,在@Component的语义基础之上细化为@Reposity,@Service,@Controller.
    有一个use-defaultbao'i-filters属性,属性默认是true,表示会扫描抱下所有的标有@Component的类,并注册为bean,也就是@Component的子注解@Service,@reposity等
    如果只想扫描包下的@Controller或其他内容,则设置use-default-filters属性为false,表示不再按照scan指定的包进行扫描,而是按照指定包进行扫描
    <context:component-scan base-package="com" user-default-filters="false">
        <context:include-filter type="regex" expression="com.tan.*"/>
    </context:component-scan>
    

    当没有设置use-default-filters属性或属性为true时,表示基于base-package包下指定扫描的具体路径。

    2. @Service()


    此注注解属于业务逻辑层,service或者manager层
    默认按照名称进行装配,如果名称可以通过name属性指定,如果没有name属性,注解写在字段上时,默认去字段名进行查找,如果注解写在setter方法上,默认按照方法属性名称进行装配。当找不到匹配的bean时,才按照类型进行装配,如果name名称一旦指定就会按照名称进行装配

    Service层:

    @Service()
    public class IocService{
    
        @Resource
        private IIocDao iiocDao;
        public void add(){
            iiocDao.add();
        }
    }
    

    3. @Repository持久层

    此注解式持久层组件,用于标注数据访问组件,即DAO组件
    DAO层
    先定义一个接口

    public interface IIocDao{
        public void add();
    }
    

    然后实现类

    //Dao层中定义了一些接口
    //表示将Dao类声明为bean
    @Repository
    public class IocDao implements IIocDao{
        public void add(){
            System.out.println("调用了Dao");
        }
    }
    
    另外一种解释: @Repository对应数据访问层Bean
    @Repository(value="userDao")
    public class UserDaoImpl extends BeansDaoImpl<User>{
        ......
    }
    

    @Repository(value=“userDao”)注解告诉Spring ,让Spring创建一个名字叫做"userDao"的UserDapImpl实例。
    当Service需要使用Spring创建的名字叫“userDao”的UserDaoImpl实例时,就可以使用@Resource(name=“userDao”)注解告诉Spring,Spring把创建好的userDao注入给Service即可。

     //注入userDao,从数据库中根据用户Id取出指定用户时需要用到
     @Resource(name = "userDao")
     private BaseDao<User> userDao;
    

    参考文章:https://www.cnblogs.com/xdp-gacl/p/3495887.html

    展开全文
  • Service Mesh

    万次阅读 2020-05-21 08:45:58
    服务网格Service Mesh的介绍

    一、微服务落地困难

    随着互联网、移动互联网的发展,微服务在国内从2015年兴起,2017、2018微服务热度很高,因为它解决了企业的实际问题,企业将一个系统的业务处理拆分成一个一个微小的服务,服务与服务之间的耦合度非常低,大大提高了系统开发的生产力,借助云计算的能力,可自动化管理微服务开发、容器化部署、监控,并完在服务容错、限流、降低等微服务治理。

    当前很多传统企业慢慢向互联网技术转型,其中微服务就是技术转型的核心,微服务在落地时遇到了很大的困难!

    微服务落地就是企业的软件系统采用微服务技术构建,开发成为云原生应用。

    什么是云原生(Cloud Native)应用?

    CNCF是一个开源Linux基金会(https://www.cncf.io/),它致力于推进云端原生应用和服务的开发,由CNCF孵化的项目目前达到20多个,其中包括当前热门的KubernetesPrometheus等;CNCF的成员包括:googleIBM、 英特尔、阿里巴巴、华为、思科、DockereBay、红帽等一百多家…

    CNCF定义的云原生应用包括以下特征:

    1. 面向微服务:面向微服务开发、测试、运维
    2. 容器化封装:在容器中运行应用程序,并作为应用程序部署的独立单元,最终应用程序运行在公有云或私有云中
    3. 自动化管理:使用自动化的管理平台对容器部署、运维进行统一调度,提高系统的资源利用率,降低运维成本

    二、Service Mesh简介

    Service Mesh(服务网格),它是一种微服务开发的理念。微服务开发要支持代码0侵入则可大大降低了微服务开发的难度,提高微服务落地的速度,即不必使用统一的微服务框架进行开发,对于一些老系统不论开发语言是什么0代码侵入则可以改为微服务。

    服务消费方采用service mesh例子:

    在这里插入图片描述
    Service MeshService A处于同一个PodPodKubernetes中的概念,Pod是一个容器环境下的“逻辑主机”,上图说明Service Mesh AService A处于同一个主机,Service Mesh AService A通过127.0.0.1本地地址通信。
    上图Service A请求Service B的流程如下:

    1. Service A请求Service mesh A
    2. Service mesh A请求Service mesh B
    3. Service mesh A请求Service mesh C

    务提供方采用service mesh例子:
    在这里插入图片描述
    服务消费方请求服务提供方都采用service mesh的例子:
    在这里插入图片描述
    上图Service A请求Service B的流程如下:

    1. Service A请求Service mesh A
    2. Service mesh A请求Service mesh B
    3. Service mesh B请求Service B

    Service Mesh作为TCP/IP之上的一个抽象层,微服务只负责业务逻辑,Sidecar来负责微服务的通信、容错、限流、降低等功能,Sidecar就是把微服务层面的功能抽取了出来,应用程序之间通过Service Mesh进行通信,如下图:
    在这里插入图片描述
    Willian MorganService Mesh(服务网格)的定义是:Service Mesh是 一个基础设施层,用于处理服务间通信。云原生应用有着复杂的服务拓扑,Service Mesh保证请求可以在这些拓扑中可靠地传输。在实际应用当中,Service Mesh通常是由一系列轻量级的网络代理组成的,它们与应用程序部署在一起,但应用程序不需要知道它们的存在。

    当该Sidecar在微服务中大量部署时,这些Sidecar节点自然就形成了一个网格:
    在这里插入图片描述

    三、为何使用Service Mesh

    1. 作为基础设施层,抽取微服务通信、治理功能
    2. 老系统0代码侵入改造为微服务
    3. Service Mesh负责微服务通信、治理功能,这样微服务专注业务开发

    四、Service Mesh发展

    业界将Spring Cloud称为第一代微服务技术,即侵入式微服务框架,将Service Mesh称为下一代的微服务技术。

    Service Mesh起源于2016年,2017年越来越多的企业开始知道Service Mesh,业界将2018年称为Service Mesh元年,预示着Service Mesh将从2018年开始发展。 Service Mesh发展至今已有如下开源项目: LinkerdEnvoyIstioConduit华为mesher新浪Motan Mesh

    展开全文
  • Web Service进阶(四)WebService注解

    万次阅读 2015-04-08 16:08:04
    Web Service 元数据注释(JSR 181) @WebService 1、serviceName: 对外发布的服务名,指定 Web Service 的服务名称:wsdl:service。缺省值为 Java 类的简单名称 + Service。(字符串) 2、endpointInterface:...
  • Service 1.Service基础知识概述   Service(服务)是一个一种可以在后台执行长时间运行操作而没有用户界面的应用组件。服务可由其他应用组件启动(如Activity),服务一旦被启动将在后台一直运行,即使启动服务...
  • 问题背景:这个问题,其实分为四个问题,思路是一致的。...- service调用service - util调用service - websocket中autowired - SpringUtils.getBean()获取bean 如果Spring项目,是推荐SpringUtil的,简单方便。
  • 使用main测试的时候是没有问题的,当放在tomact下,通过方法调用,就会在Service service = new Service()处卡主,使用try/catch捕获异常,会看到java.lang.reflect.InvocationTargetException,但在控制台并不输出...
  • Failed to restart network.service: Unit network.service not found

    万次阅读 多人点赞 2019-09-30 16:54:49
    在配置完网络设置时重启时会出现这个问题,,原因是和NetworkManager服务有冲突,...service NetworkManager stop //关闭NetworkManager service network restart //启动network服务 Network和NetworkManager区别 ...
  • VMware Workstation 未能启动 VMware Authorization Service

    万次阅读 多人点赞 2018-05-15 15:29:33
    这个是因为Windows系统服务中的VMware Authorization Service未启动。 按win+r快捷键,输入services.msc,点击确定 服务列表找到 VMware Authorization Service 并双击 修改启动类型为自动或手动,点击应用 ...
  • 今天在centOS 7下更改完静态ip后发现network服务重启不了,翻遍了网络,尝试...首先看问题:执行service network restart命令后出现下面的错误:     Restarting network (via systemctl): Job for network...
  • 解决 adobe 的 FlashHelperService.exe 的 FF新闻 弹窗广告

    万次阅读 多人点赞 2019-08-15 15:12:50
    1 ctrl+alt+del 结束 FlashHelperService.exe 的进程 2 禁用FlashHelperService 的服务: 打开 打开服务启动项(win10 windows+R 使用 services.msc 命令)找到 FlashHelperService ,双击,禁用即可 3.通过...
  • Failed to start mysqld.service: Unit not found

    万次阅读 热门讨论 2019-08-12 10:26:35
    systemctl start mysql.service 要启动MySQL数据库是却是这样的提示 Failed to start mysqld.service: Unit not found 解决方法如下: 首先需要安装mariadb-server yum install -y mariadb-server 启动...
  • 在上一篇文章中,我们学习了Android Service相关的许多重要内容,包括Service的基本用法、Service和Activity进行通信、Service的销毁方式、Service与Thread的关系、以及如何创建前台Service。以上所提到的这些知识点...
  • Service和Activity有啥区别?Service有哪些类型?它们是怎么实现?什么场景下使用?本文将详细为你介绍Service的使用方法,让你深入浅出。
  • 在Linux中利用Service命令添加系统服务及开机自启动

    万次阅读 多人点赞 2017-12-13 15:44:08
    通过查资料发现linux启动服务是用SERVICE +COMMAND。这里的command命令本身也是一个脚本。比如说:service networking start;中networking就是一个shell脚本。注意:这里的脚本没有文件后缀.sh。 接下来,将介绍...
  • Android Service: 启动service, 停止service

    万次阅读 2014-05-15 20:40:32
    [ 启动service ] 1. 定义Service类 2. 在manifest中注册 3. 在activity中启动 1. 定义Service
  • Service基础

    千次阅读 2016-02-17 09:19:16
    概述Service是Android四大组件之一,主要两个目的: 后台运行和跨进程访问。通过启动一个Service,可以在不显示界面的前提下在后台运行指定的任务,这样可以不影响用户做其他事情。通过跨进程服务(AIDL)可以实现...
  • 彻底关闭Antimalware Service Executable(windows defender)

    万次阅读 热门讨论 2019-12-02 10:28:15
    因为我的电脑并不是特别好,而Antimalware Service Executable服务占用的CPU过高,导致电脑特别卡,所以就在网上查找资料实现了对Antimalware Service Executable的关闭。 首先,转载一个博文: 关闭Antimalware ...
  • 安卓Service 详解

    万次阅读 多人点赞 2018-06-07 17:36:33
    Service全部内容基本会在本篇涉及到,我们将围绕以下主要知识点进行分析:Service简单概述Service在清单文件中的声明Service启动服务实现方式及其详解Service绑定服务的三种实现方式关于启动服务与绑定服务间的...
  • 对于java web开发中,service到底要不要引入其他的dao或service,注入DAO我就不认同了,感觉结构更加混乱。但是看了百度感觉各有各说法,让我感觉越发混乱。 我感觉service注入service不可避免吧。比如我有一个业务...
  • java.lang.IllegalStateException: Failed to check the status of the service com.pinyougou.sellergoods.service.SellerService. No provider available for the service ...
  • 之前的一篇文章谈到了贫血模型,而ddd是提倡充血模型的,即尽量把逻辑写在domain object中,而不是写一大堆的service类,对数据类进行操作。那么为什么ddd里会有service类呢?这篇文章会对service进行说明。 ddd...
  • Android service 启动篇之 startService

    万次阅读 2018-08-31 16:28:10
    Android 中service 详解 中说明了大概背景,这里不再过叙述了。 代码基于Android O    Android基础总结之六:Sevice 中是应用端对于service 使用的总结,其中看到启动service 需要的接口有startService 和...
  • ROS实操入门系列(四)1、service通讯讲解 2、通过实际需求理解ServiceService通讯需求Server端实现调试ServerClient端实现Service命令行工具 Service通讯 ROS提供了节点与节点间通讯的另外一种方式:service通讯。...
  • Android Service 服务(一)—— Service

    万次阅读 多人点赞 2012-03-17 13:44:18
    一、 Service简介Service是android 系统中的四大组件之一(Activity、Service、BroadcastReceiver、ContentProvider),它跟Activity的级别差不多,但不能自己运行只能后台运行,并且可以和其他组件进行交互。...
  • 一、startService代码流程 Activity.java startService(mBase.startService())Context.java startService()ContextImpl.java startService() → startServiceCommon(ActivityManager.getService().startService())...
  • android中Service使用startService

    万次阅读 2016-07-09 09:25:00
    Service作为android四大组件之一,那么什么情况下我们会使用到Service呢?在这里我把它归纳成两种情况得运用场景: 1、用于长期执行某些操作,并且甚至与UI(主)线程没有交互。比如启动app直接去网络下载文件 2、跨...
  • Android使用Service播放音乐

    万次阅读 2017-08-16 18:33:27
    像音乐这种耗时的和适合后台操作的应当放在Service中进行操作,而不是放在Activity,下面就介绍使用Service的音乐播放器 先创建一个MusicService,在Android Studio中,点击包名右键New-->Service-->Service 如果是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 600,345
精华内容 240,138
关键字:

service