Android -- 带你从源码角度领悟Dagger2入门到放弃(二)
1,接着我们上一篇继续介绍,在上一篇我们介绍了简单的@Inject和@Component的结合使用,现在我们继续以老师和学生的例子,我们知道学生上课的时候都会有书籍来辅助听课,先来看看我们之前的Student代码
package com.qianmo.rxjavatext; import android.util.Log; import javax.inject.Inject; /**
* Created by Administrator on 2017/4/17 0017.
* E-Mail:543441727@qq.com
*/ public class Student {
private int id;
private String name;
private Course[] course; @Inject
public Student() {
System.out.println("Student create!!!");
} public Student(int id, String name, Course[] course) {
this.id = id;
this.name = name;
this.course = course;
} public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Course[] getCourse() {
return course;
} public void setCourse(Course[] course) {
this.course = course;
} public void startLessons() {
System.out.println("开始上课了");
}
}
添加书籍对象,在类中有书籍的姓名属性,还有变黑动作(这里是瞎加上这个动作的),Book的代码如下:
/**
* Created by Administrator on 2017/4/20 0020.
* E-Mail:543441727@qq.com
*/ public class Book { private String name; public Book(String name) {
this.name = name;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public void changeBlack() {
System.out.println(name + "我一本新书被翻黑了。。。。");
}
}
然后我们student中的构造函数也要添加了如下代码,且以前的构造函数需要删掉
package com.qianmo.rxjavatext; import android.util.Log; import javax.inject.Inject; /**
* Created by Administrator on 2017/4/17 0017.
* E-Mail:543441727@qq.com
*/ public class Student {
private int id;
private String name;
private Course[] course;
private Book book; @Inject
public Student(Book book) {
System.out.println("Student create with book!!!");
} public Student(int id, String name, Course[] course) {
this.id = id;
this.name = name;
this.course = course;
} public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Course[] getCourse() {
return course;
} public void setCourse(Course[] course) {
this.course = course;
}
public void startLessons() {
System.out.println("开始上课了");
book.changeBlack();
}
}
这时候我们会有一个猜想,当我们一个类中存在两个构造函数被标记了@Inject标记呢,那我们来试试代码如下:
@Inject
public Student() {
System.out.println("Student create!!!");
} @Inject
public Student(Book book) {
System.out.println("Student create with book!!!");
}
但是你最后运行的时候会直接报错了,报错信息如下,翻译过来意思就是说Student类中只能包含一个@Inject标记修饰构造函数
Error:(19, 12) 错误: Types may only contain one @Inject constructor.
OK,我们肯定现在脑袋了有这种疑问,要是我真的是想使用两个或者多个构造函数呢,别急,后面会和大家在实例中来讲解怎么使用的,好了还是回到我们正题上来,现在我们Student构造函数中出现了一个book对象,我们可能会想,有可能Dagger2会帮我们继续new一个Book对象放入Student构造函数中呐,好,我们抱着它能有这么智能我们来运行一下工程。
哦哦,sorry,报错了,我们来看一下报错提示,说不定我们能从报错信息来找到解决方法呐
Error:(12, 9) Gradle: 错误: com.qianmo.rxjavatext.Book cannot be provided without an @Inject constructor or from an @Provides-annotated method.
从上面你的信息我们知道它说book对象中没有提供一个标注为@Inject的构造方法,或者@Provides的方法。
好的我们就先用第一种方法试试,标记Book构造函数为@Inject,并修改在Student类中的成员变量book也标记成@Inject,运行一下项目,运行结构如下
Student create with book!!!
开始上课了
我一本新书被翻黑了。。。。
呃,可以了,没想到就这样可以了,666啊 ,这是我们使用的第一个方法,我们现在根据它之前报错信息的第二个方法来实现提供一个@Provides标记的方法
2,@Module和@Provides的使用
而使用@Provides标记就要使用@Module标签了,先来回顾一下这两个注解标签的定义
@module,标注用于提供需要注入的实例的类,当我们要提供第三方的依赖时,使用Inject注解类的构造函数很明显不现实,这时就可以使用这个注解,在module中提供。
@Provides,使用在用@module标注的类里面,告诉dagger2来这里找依赖。
除了构造函数提供依赖,还能用Module提供。所以这里我们要创建一个Module,并创建@Provides注解标签修饰的对应的提供该对象的方法
@Module
public class TeacherModule { @Provides
Book provideBook() {
return new Book();
}
}
这里需要解释一波了,首先provideBook这个方法名是固定的吗,当然不是固定的,不过我们为了逻辑清晰,一般采用然后修改provide开头,后面再加上类名,切记一定要加上@Provide标签,要让桥接器知道在这里找依赖。
然后要修改TeacherComponent中的module引用
package com.qianmo.rxjavatext; import dagger.Component; /**
* Created by Administrator on 2017/4/20 0020.
* E-Mail:543441727@qq.com
*/
@Component(modules = TeacherModule.class)
public interface TeacherComponent {
void injectA(Teacher teacher);
}
修改调用方法
DaggerTeacherComponent.builder().teacherModule(new TeacherModule()).build().injectA(this);
看一下运行效果
Student create with book!!!
开始上课了
我一本新书被翻黑了。。。。
OK,打印结果没问题,这里我们想着既然Module能够提供依赖,那么我们把之前的Student的构造函数依赖添加到这里,代码如下:
package com.qianmo.rxjavatext; import dagger.Module;
import dagger.Provides; /**
* Created by Administrator on 2017/4/20 0020.
* E-Mail:543441727@qq.com
*/ @Module
public class TeacherModule { @Provides
Book provideBook() {
return new Book();
} @Provides
Student provideStudent(Book book){
return new Student(book);
}
}
这时候我们会有一个疑问,我们在Student构造函数加过@Inject注解又在Module中提供了依赖,这两个会不会冲突啊,我们心里面先带着这个疑问,运行一下项目,发现没什么问题运行结果如下:
Student create with book!!!
开始上课了
我一本新书被翻黑了。。。。
那么我们现在会有一个疑问了,到底我们是我们通过@Inject注解标记Student构造函数起了作用还是我们的Module中的provideStudent方法起作用了呢?那么是时候看一波我们的源码了,我们这次一共涉及到四个类DaggerTeacherComponent、Teacher_MembersInjector、TeacherModule_ProvideStudentFactory、TeacherModule_ProvideBookFactory,前面两个类和我们之前一篇文章源码分析类似,后面两个类从之前的StudentFactory变成了TeacherModule_ProvideStudentFactory、TeacherModule_ProvideBookFactory这两个类,从字面上我们也可以理解一个是从TeacherModule中获取Student对象的提供工厂,一个是从TeacherModule中获取Book对象的提供工厂。不多说,我们继续先来看看DaggerTeacherComponent类的源码
package com.qianmo.rxjavatext; import dagger.MembersInjector;
import dagger.internal.Preconditions;
import javax.annotation.Generated;
import javax.inject.Provider; @Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://google.github.io/dagger"
)
public final class DaggerTeacherComponent implements TeacherComponent {
private Provider<Book> provideBookProvider; private Provider<Student> provideStudentProvider; private MembersInjector<Teacher> teacherMembersInjector; private DaggerTeacherComponent(Builder builder) {
assert builder != null;
initialize(builder);
} public static Builder builder() {
return new Builder();
} public static TeacherComponent create() {
return builder().build();
} @SuppressWarnings("unchecked")
private void initialize(final Builder builder) { this.provideBookProvider = TeacherModule_ProvideBookFactory.create(builder.teacherModule); this.provideStudentProvider =
TeacherModule_ProvideStudentFactory.create(builder.teacherModule, provideBookProvider); this.teacherMembersInjector = Teacher_MembersInjector.create(provideStudentProvider);
} @Override
public void injectA(Teacher teacher) {
teacherMembersInjector.injectMembers(teacher);
} public static final class Builder {
private TeacherModule teacherModule; private Builder() {} public TeacherComponent build() {
if (teacherModule == null) {
this.teacherModule = new TeacherModule();
}
return new DaggerTeacherComponent(this);
} public Builder teacherModule(TeacherModule teacherModule) {
this.teacherModule = Preconditions.checkNotNull(teacherModule);
return this;
}
}
}
可以看到和我们之前的DaggerTeacherComponent类源码有所不同,多了teacherModule、provideBookProvider、provideStudentProvider三个成员变量,多了teacherModule()方法。
ok,继续按照我们之前的方法分析首先调用DaggerTeacherComponent.builder()创建出一个Builder对象出来,再调用DaggerTeacherComponent.builder().teacherModule(new TeacherModule()),注意了,请看teacherModule()方法里面的源码
public Builder teacherModule(TeacherModule teacherModule) {
this.teacherModule = Preconditions.checkNotNull(teacherModule);
return this;
}
这里先检查传递的teacherModule对象是否为空,让不为空的话将将值赋值到成员变量this.teacherModule上。
OK,我们继续往下看DaggerTeacherComponent.builder().teacherModule(new TeacherModule()).build(),接下来调用而是build方法,来看看具体的源码
public TeacherComponent build() {
if (teacherModule == null) {
this.teacherModule = new TeacherModule();
}
return new DaggerTeacherComponent(this);
} private DaggerTeacherComponent(Builder builder) {
assert builder != null;
initialize(builder);
} private void initialize(final Builder builder) { this.provideBookProvider = TeacherModule_ProvideBookFactory.create(builder.teacherModule); this.provideStudentProvider =
TeacherModule_ProvideStudentFactory.create(builder.teacherModule, provideBookProvider); this.teacherMembersInjector = Teacher_MembersInjector.create(provideStudentProvider);
}
从上面你的源码可以看到,首先我们在build方法判断teacherModule属性是否为空,如果为空则自己new一个TeacherModule对象(那这里是不是表示我们之前的teacherModule(new TeacherModule())方法可以偷懒不用写? 大家可以去试一试,的确可以的,手动微笑....),然后调用DaggerTeacherComponent类中的构造函数,在构造函数中调用initialize()方法,好了这里是重点了,在这里我们赋值了provideBookProvider、provideStudentProvider两个成员对象,所以我们现在看看TeacherModule_ProvideBookFactory 、TeacherModule_ProvideStudentFactory中的create方法干了什么
package com.qianmo.rxjavatext; import dagger.internal.Factory;
import dagger.internal.Preconditions;
import javax.annotation.Generated; @Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://google.github.io/dagger"
)
public final class TeacherModule_ProvideBookFactory implements Factory<Book> {
private final TeacherModule module; public TeacherModule_ProvideBookFactory(TeacherModule module) {
assert module != null;
this.module = module;
} @Override
public Book get() {
return Preconditions.checkNotNull(
module.provideBook(), "Cannot return null from a non-@Nullable @Provides method");
} public static Factory<Book> create(TeacherModule module) {
return new TeacherModule_ProvideBookFactory(module);
}
}
package com.qianmo.rxjavatext; import dagger.internal.Factory;
import dagger.internal.Preconditions;
import javax.annotation.Generated;
import javax.inject.Provider; @Generated(
value = "dagger.internal.codegen.ComponentProcessor",
comments = "https://google.github.io/dagger"
)
public final class TeacherModule_ProvideStudentFactory implements Factory<Student> {
private final TeacherModule module; private final Provider<Book> bookProvider; public TeacherModule_ProvideStudentFactory(TeacherModule module, Provider<Book> bookProvider) {
assert module != null;
this.module = module;
assert bookProvider != null;
this.bookProvider = bookProvider;
} @Override
public Student get() {
return Preconditions.checkNotNull(
module.provideStudent(bookProvider.get()),
"Cannot return null from a non-@Nullable @Provides method");
} public static Factory<Student> create(TeacherModule module, Provider<Book> bookProvider) {
return new TeacherModule_ProvideStudentFactory(module, bookProvider);
}
}
大家请看这两个类中的get方法中的参数!!!! 首先TeacherModule_ProvideBookFactory中调用的是module.provideBook(),获取到我们的book创建的对象,在看TeacherModule_ProvideStudentFactory中的get方法首先拿到TeacherModule_ProvideStudentFactory中的book对象,然后在调用 module.provideStudent(bookProvider.get())方法,拿到TeacherModule中创建的Student对象。
ok现在基本流程清楚了,最后调用injectA(this)方法在Teacher_MembersInjector类中把当前的Teacher对象中的student属性被赋值到TeacherModule_ProvideStudentFactory.get()上去,这样我们的赋值就完成了。
那么这里我们可以有一下结论
我们有两种方式可以提供依赖,一个是注解了@Inject的构造方法,一个是在Module里提供的依赖,那么Dagger2是怎么选择依赖提供的呢,规则是这样的: 步骤1:查找Module中是否存在创建该类的方法。
步骤2:若存在创建类方法,查看该方法是否存在参数
步骤2.1:若存在参数,则按从步骤1开始依次初始化每个参数
步骤2.2:若不存在参数,则直接初始化该类实例,一次依赖注入到此结束
步骤3:若不存在创建类方法,则查找Inject注解的构造函数,看构造函数是否存在参数 步骤3.1:若存在参数,则从步骤1开始依次初始化每个参数 步骤3.2:若不存在参数,则直接初始化该类实例,一次依赖注入到此结束 概括一下就是从注解了@Inject的对象开始,从Module和注解过的构造方法中获得实例,若在获取该实例的过程中需要其他类的实例,则继续获取被需要类的实例对象的依赖,同样是从Module和标注过的构造方法中获取,并不断递归这个过程直到所有被需要的类的实例创建完成,在这个过程中Module的优先级高于@Inject注解过的构造方法。
这样我们就懂了为什么同事存在Module和@Inject都不会报错,且它对Module和@Inject提供对象实例的优先级关系了。
3、@Qulifier的使用
现在继续扩展业务,由于学校扩招,现在任课老师下面由之前的一个学生变成了两个学生,且新来的那个学生是没有书籍的,那么在我们java代码中怎么表示这种场景呢?
package com.qianmo.rxjavatext; import javax.inject.Inject; /**
* Created by Administrator on 2017/4/20 0020.
* E-Mail:543441727@qq.com
*/ public class Teacher {
//想持有学生对象
@Inject
Student student1; //带了书的 @Inject
Student student2; //没带了书的 public Teacher() {
DaggerTeacherComponent.builder().teacherModule(new TeacherModule()).build().injectA(this);
} public void teacher() {
student1.startLessons();
student2.startLessons();
} public static void main(String[] args) {
new Teacher().teacher();
}
}
自该修改Student中的构造函数,添加不带书的构造方法
public Student(Book book) {
System.out.println("Student create with book!!!");
this.book = book;
} public Student() {
System.out.println("Student create without book!!!");
this.book = new Book("对不起我没有书啊");
}
这时候我们想是想student2获取的是Student()的无参构造的对象,所以我们相当然的在我们的Module中添加对应的提供方法,代码如下:
package com.qianmo.rxjavatext; import dagger.Module;
import dagger.Provides; /**
* Created by Administrator on 2017/4/20 0020.
* E-Mail:543441727@qq.com
*/ @Module
public class TeacherModule { @Provides
Book provideBook() {
return new Book("我是真实的书籍呢...");
} /**
* 提供有书的学生
* @param book
* @return
*/
@Provides
Student provideStudentA(Book book) {
return new Student(book);
} /**
* 提供没书的学生
* @return
*/
@Provides
Student provideStudentB() {
return new Student();
}
}
然后你开开心心的运行项目,会发现直接报错了,报错如下:
Error:(10, 9) Gradle: 错误: com.qianmo.rxjavatext.Student is bound multiple times:
@Provides com.qianmo.rxjavatext.Student com.qianmo.rxjavatext.TeacherModule.provideStudentA(com.qianmo.rxjavatext.Book)
@Provides com.qianmo.rxjavatext.Student com.qianmo.rxjavatext.TeacherModule.provideStudentB()
明面字义翻译过来就是“绑定的时候迷失了自己在provideStudentA、provideStudentB方法之间”,我们专业术语叫“做依赖迷失”,因为Dagger2是根据返回类型来进行依赖注入的,但是这里我们提供了A、B两个方法返回相同的对象,这时候我们的student1、studnet2不知道他们自己到底是要创建有书的对象呢还是没有书的对象呢。
so,为了解决这个问题,我们的Dagger2提供了@Qulifier,可以通过自定义注解,来告诉Dagger2我这次到底是想依赖那个方法,这里不会注解的同学可以去看一下我之前写的这篇文章,那我们就来创建StudentA和StudnetB自定义注解
package com.qianmo.rxjavatext; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import javax.inject.Qualifier; /**
* Created by Administrator on 2017/4/21 0021.
* E-Mail:543441727@qq.com
*/
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface StudentA {
}
package com.qianmo.rxjavatext; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import javax.inject.Qualifier; /**
* Created by Administrator on 2017/4/21 0021.
* E-Mail:543441727@qq.com
*/
@Qualifier
@Retention(RetentionPolicy.RUNTIME)
public @interface StudentB {
}
然后在Module中添加这个注解
/**
* 提供有书的学生
* @param book
* @return
*/
@StudentA
@Provides
Student provideStudentA(Book book) {
return new Student(book);
} /**
* 提供没书的学生
* @return
*/
@StudentB
@Provides
Student provideStudentB() {
return new Student();
}
在需要使用student对象的地方添加
//想持有学生对象
@Inject
@StudentA
Student student1; //带了书的 @Inject
@StudentB
Student student2; //没带了书的
ok,运行一下项目,看一下打印效果
Student create with book!!!
Student create without book!!!
开始上课了
我一本新书被翻黑了。。。。我是真实的书籍呢...
开始上课了
我一本新书被翻黑了。。。。对不起我没有书啊
没问题,这里我们Dagger2为了让我们使用方便实际上是提供了一个@Name标签供我们使用的,看一下它里面的内容
@Qualifier
@Documented
@Retention(RUNTIME)
public @interface Named { /** The name. */
String value() default "";
}
在底层也是使用了我们@Qualifier标签的,所以如果使用@Name标签来实现我们上面的效果的话是这样的
/**
* 提供有书的学生
* @param book
* @return
*/
@Provides
@Named("StudentA")
Student provideStudentA(Book book) {
return new Student(book);
} /**
* 提供没书的学生
* @return
*/
@Provides
@Named("StudentB")
Student provideStudentB() {
return new Student();
}
//想持有学生对象
@Inject
@Named("StudentA")
Student student1; //带了书的 @Inject
@Named("StudentB")
Student student2; //没带了书的
哈哈哈,看到这儿有没有同学想说我是马后炮的(其实,只能我们自己知道了它是怎么实现的才能更好的使用),说你直接介绍@Name标签不就行了,但是不利于我们之后的深层次的学习。
4,@Scope的使用
这个标签不是很好理解,给的解释是该注解能够使同一个Component中的对象保持唯一,即单例(一定要记住是局部单例)。
那么我们来写一个栗子试试
首先继续自定义注解,并添加
package com.qianmo.rxjavatext; import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy; import javax.inject.Qualifier;
import javax.inject.Scope; /**
* Created by Administrator on 2017/4/21 0021.
* E-Mail:543441727@qq.com
*/
@Scope
@Retention(RetentionPolicy.RUNTIME)
public @interface StudentOnlyOne {
}
在B中添加方法标签的引用
/**
* 提供没书的学生
* @return
*/
@Provides
@StudentOnlyOne
@Named("StudentB")
Student provideStudentB() {
return new Student();
}
修改Teacher中的两个学生变量的使用,都是用B方法提供Student对象
@Inject
@Named("StudentB")
Student student1; //带了书的 @Inject
@Named("StudentB")
Student student2; //没带了书的
最后,很重要!!!在你的component中添加上面标注!!!!,不然你就等着bug满天飞吧(在这儿趟坑了很久)
package com.qianmo.rxjavatext; import dagger.Component; /**
* Created by Administrator on 2017/4/20 0020.
* E-Mail:543441727@qq.com
*/
@StudentOnlyOne
@Component(modules = TeacherModule.class)
public interface TeacherComponent {
void injectA(Teacher teacher);
}
ok,运行一下,看一下打印效果,
Student create without book!!!
开始上课了
我一本新书被翻黑了。。。。对不起我没有书啊
开始上课了
我一本新书被翻黑了。。。。对不起我没有书啊
书的确只被创建了一次,ok,其实我们Dagger2中也提供了封装好了的@Scope,就是我们的@Singleton,看一下它的源码
@Scope
@Documented
@Retention(RUNTIME)
public @interface Singleton {}
也是应用了@Scope标签,对不起,又马后炮了一次(哈哈哈........)
到这里我们的Dagger2的标签基本上就全部学习完了,后面一篇我将和大家一起看看,在Android中的Activity ,Dagger2能帮我们做些什么
最后!!!还有一个很关键事:最近打算辞职回北京,有没有大神同学推荐工作,带带啊啊啊啊啊
下一篇:Android -- 带你从源码角度领悟Dagger2入门到放弃(三)
Android -- 带你从源码角度领悟Dagger2入门到放弃(二)的更多相关文章
- Android -- 带你从源码角度领悟Dagger2入门到放弃
1,以前的博客也写了两篇关于Dagger2,但是感觉自己使用的时候还是云里雾里的,更不谈各位来看博客的同学了,所以今天打算和大家再一次的入坑试试,最后一次了,保证最后一次了. 2,接入项目 在项目的G ...
- Android -- 带你从源码角度领悟Dagger2入门到放弃(一)
1,以前的博客也写了两篇关于Dagger2,但是感觉自己使用的时候还是云里雾里的,更不谈各位来看博客的同学了,所以今天打算和大家再一次的入坑试试,最后一次了,保证最后一次了. 2,接入项目 在项目的G ...
- Android -- 带你从源码角度领悟Dagger2入门到放弃(三)
1, 前面两篇文章我们知道了怎么使用常用的四种标签,现在我们结合我们自己的项目中去简单的使用 在我们搭建项目的时候,一般会创建自己的Application,在里面进行一些初始化如一些第三方的Green ...
- 消息队列高手课,带你从源码角度全面解析MQ的设计与实现
消息队列中间件的使用并不复杂,但如果你对消息队列不熟悉,很难构建出健壮.稳定并且高性能的企业级系统,你会面临很多实际问题: 如何选择最适合系统的消息队列产品? 如何保证消息不重复.不丢失? 如果你掌握 ...
- Android 带你从源码的角度解析Scroller的滚动实现原理
转帖请注明本文出自xiaanming的博客(http://blog.csdn.net/xiaanming/article/details/17483273),请尊重他人的辛勤劳动成果,谢谢! 今天给大 ...
- Android AsyncTask完全解析,带你从源码的角度彻底理解
转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/11711405 我们都知道,Android UI是线程不安全的,如果想要在子线程里进 ...
- [转]Android事件分发机制完全解析,带你从源码的角度彻底理解(上)
Android事件分发机制 该篇文章出处:http://blog.csdn.net/guolin_blog/article/details/9097463 其实我一直准备写一篇关于Android事件分 ...
- 【转】Android事件分发机制完全解析,带你从源码的角度彻底理解(下)
转载请注明出处:http://blog.csdn.net/guolin_blog/article/details/9153761 记得在前面的文章中,我带大家一起从源码的角度分析了Android中Vi ...
- [学习总结]7、Android AsyncTask完全解析,带你从源码的角度彻底理解
我们都知道,Android UI是线程不安全的,如果想要在子线程里进行UI操作,就需要借助Android的异步消息处理机制.之前我也写过了一篇文章从源码层面分析了Android的异步消息处理机制,感兴 ...
随机推荐
- 黑苹果macOS Sierra 10.12 安装教程(venue11 pro测试)
黑苹果macOS Sierra 10.12 安装教程(venue11 pro测试) 2017-03-12 03:46:24 by SemiconductorKING PS:刚刚装好黑苹果,来记录一篇折 ...
- java算法 蓝桥杯(题+答案) 方格填数
6.方格填数 (结果填空) 如下的10个格子 (如果显示有问题,也可以参看[图1.jpg]) 填入0~9的数字.要求:连续的两个数字不能相邻.(左右.上下.对角都算相邻) 一共有多少种可能的填数方案 ...
- oracle xe 数据库用户操作
在system账号登录获得system权限,然后对用户进行操作 --创建表空间create tablespace tablespace_name datafile 'D:\tablespace_nam ...
- Android OS体系结构详解
Google于2007年11月5日宣布的基于Linux平台的开源手机操作系统的名称,该平台由操作系统.中间件.用户界面和应用软件组成,号称是首个为移动终端打造的真正开放和完整的移动软件. 架构详解 下 ...
- 10分钟精通SharePoint-搜索
大势所趋随着企业内容和文档数量的骤增,快速定位到所需材料和内容已经迫不及待,这也是所有企业所面临的共同的挑战,应这个大的趋势,"搜索"闪亮登上了企业协作(SharePoint)舞台 ...
- ehcache 使用笔记
要想使用 java 的本地缓存,可以考虑用 ehcache,或者 guava. guava 更高端一点,可以自动定时刷新.我选择了 ehcache. 在 spring 中是集成了 ehcache 的. ...
- 解决 Linux error while loading shared libraries: cannot open shared object file: No such file or directory
安装最新版本Emqtt,参照官方文档安装后,执行报错: Linux error while loading shared libraries libsctp.so.1: cannot open sha ...
- Bootsrap 的 Carousel
一.简介 Carousel 就是指轮播图,这里 有完整的代码例子.它可以很简单的就构造出来,结构如下: div.carousel.slide[data-ride="carousel" ...
- Linux下httpd服务与Apache服务的查看和启动
转:http://jingyan.baidu.com/article/63f236282d43170209ab3d43.html 这里简要介绍Linux环境中Apache也就是httpd服务的启动,查 ...
- spring学习——注入静态对象属性
spring注入静态对象属性时,因为虚拟机类加载问题,直接在属性上使用@Autowired 是不可以的.需要在属性对应的set方法上@Autowired,并且,set方法不能定义为static. 1. ...