导航:首页 > 源码编译 > dagger2源码讲解

dagger2源码讲解

 发布时间：2022-07-17 02:07:24

① Dagger2 Scope 注解能保证依赖在 component 生命周期内的单例性吗

用Dagger2在android中实现依赖注入 依赖注入这个模式（模式已经用烂了，这里再烂一次）是用来给应用的各部分解耦的。使应用开发更加可扩展，更容易维护。通过本文你会学到如何使用Dagger2来处理依赖。 简介 如果以对象需要另外的一个对象才能完

② dagger2 android 怎么用

简单的说 Dagger就是用来创造这个容器，所有需要被依赖的对象在Dagger的容器中实例化，并通过Dagger注入到合适的地方，实现解耦，MVP框架就是为解耦而生，因此MVP和Dagger是绝配；

举个栗子？
通常情况下我们引用一个类的做法：
我们先定义一个简单的类：

1 public class User {
2 private String name;
3
4 public String getName() {
5 return name;
6 }
7
8 public void setName(String name) {
9 this.name = name;
10 }
11 }

③ Android Dagger2 @Provides问题

GithubApiMole_ProvideGitHubServiceFactory 类中有两个成员，一个是提供（@Provides）GithubService 所在的 mole 类，一个是创建GithubService方法所需参数的retrofitProvider（从这里可以看出Dagger2需要创建retrofitProvider的工厂）。然后通过 mole.provdeGitHubService()方法来创建 GithubApiService实例，这样最终穿件了在ReposListActivity中注入的依赖实例。

④ 为啥dagger2 注解不到对象

Dagger有一辅助技能叫治疗者，以下是天幻对这个技能的解释
治疗者 いやしの Healer 让攻击的对象回复HP(敌我双方均可)
你可能是用了修改器 让吉坦学会了这项技能
所以导致给敌加血 再修改回来即可

⑤ android dagger2在fragment中怎么用

在component中inject fragment就好
AppComponent通常提供全局的对象以便于其他的组件依赖使用，比如context,rest api接口等，这些都是全局的单例对象
MainActivityComponent特意针对MainActivity，所以它只提供其对应的MainActivityPresenter，因为其依赖AppComponent，所以它可以使用AppComponent提供的对象

这里使用http://blog.csdn.net/tiankong1206/article/details/46486401 这里的一个例子，主要把其中的一些细节稍微说的详细点,下面这一段说明来自网上：
@Inject: 通常在需要依赖的地方使用这个注解。换句话说，你用它告诉Dagger这个类或者字段需要依赖注入。这样，Dagger就会构造一个这个类的实例并满足他们的依赖。

@Mole: Moles类里面的方法专门提供依赖，所以我们定义一个类，用@Mole注解，这样Dagger在构造类的实例的时候，就知道从哪里去找到需要的 依赖。moles的一个重要特征是它们设计为分区并组合在一起（比如说，在我们的app中可以有多个组成在一起的moles）。

@Provide: 在moles中，我们定义的方法是用这个注解，以此来告诉Dagger我们想要构造对象并提供这些依赖。

@Component: Components从根本上来说就是一个注入器，也可以说是@Inject和@Mole的桥梁，它的主要作用就是连接这两个部分。 Components可以提供所有定义了的类型的实例，比如：我们必须用@Component注解一个接口然后列出所有的@Moles组成该组件，如 果缺失了任何一块都会在编译的时候报错。所有的组件都可以通过它的moles知道依赖的范围。

@Scope: Scopes可是非常的有用，Dagger2可以通过自定义注解限定注解作用域。后面会演示一个例子，这是一个非常强大的特点，因为就如前面说的一样，没 必要让每个对象都去了解如何管理他们的实例。在scope的例子中，我们用自定义的@PerActivity注解一个类，所以这个对象存活时间就和 activity的一样。简单来说就是我们可以定义所有范围的粒度(@PerFragment, @PerUser, 等等)。

1、首先是Mole

[java] view plain print?
@Mole
public class MainActivityMole {

private MainActivity mainActivity;

public MainActivityMole(MainActivity mainActivity) {
this.mainActivity = mainActivity;
}

@Provides
@ActivityScope
MainActivity provideMainActivity() {
return mainActivity;
}

@Provides
@ActivityScope
MainActivityPresenter provideMainActivityPresenter(MainActivity mainActivity, User user) {
return new MainActivityPresenter(mainActivity, user);
}

}

注意里面的provide方法，我们后面还可以看到，这里的语法是@Mole @Providers

然后是Component

[java] view plain print?
@ActivityScope
@Component(moles = {MainActivityMole.class , AppServiceMole.class})
public interface MainActivityComponent {
MainActivity inject(MainActivity mainActivity);

}

这里的MainActivityComponent包含两个Mole，一个是我们上面列出来的MainActivityMole，另一个是AppServiceMole

接下来就是使用了，在MainActivity中：

[java] view plain print?
@Override
protected void setupActivityComponent() {
DaggerMainActivityComponent.builder()
.mainActivityMole(new MainActivityMole(this))
.appServiceMole(new AppServiceMole())
.build()
.inject(this);

}
这里在build之前把Component用到的每一个Mole的构造函数初始化一下，在build之后inject注入，我们看一下这个自动生成的DaggerMainActivityComponent

[java] view plain print?
package com.example.lwp.mvp.ui.activity.component;

import com.example.lwp.mvp.data.AppServiceMole;
import com.example.lwp.mvp.data.AppServiceMole_ProvideUserFactory;
import com.example.lwp.mvp.model.User;
import com.example.lwp.mvp.ui.activity.MainActivity;
import com.example.lwp.mvp.ui.activity.MainActivity_MembersInjector;
import com.example.lwp.mvp.ui.activity.mole.MainActivityMole;
import com.example.lwp.mvp.ui.activity.mole.MainActivityMole_ProvideMainActivityFactory;
import com.example.lwp.mvp.ui.activity.mole.MainActivityMole_;
import com.example.lwp.mvp.ui.activity.presenter.MainActivityPresenter;
import dagger.MembersInjector;
import dagger.internal.MembersInjectors;
import dagger.internal.ScopedProvider;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class DaggerMainActivityComponent implements MainActivityComponent {
private Provider<MainActivity> provideMainActivityProvider;
private Provider<User> provideUserProvider;
private Provider<MainActivityPresenter> ;
private MembersInjector<MainActivity> mainActivityMembersInjector;

private DaggerMainActivityComponent(Builder builder) {
assert builder != null;
initialize(builder);
}

public static Builder builder() {
return new Builder();
}

private void initialize(final Builder builder) {
this.provideMainActivityProvider = ScopedProvider.create(MainActivityMole_ProvideMainActivityFactory.create(builder.mainActivityMole));
this.provideUserProvider = AppServiceMole_ProvideUserFactory.create(builder.appServiceMole);
this. = ScopedProvider.create(MainActivityMole_.create(builder.mainActivityMole, provideMainActivityProvider, provideUserProvider));
this.mainActivityMembersInjector = MainActivity_MembersInjector.create((MembersInjector) MembersInjectors.noOp(), );
}

@Override
public MainActivity inject(MainActivity mainActivity) {
mainActivityMembersInjector.injectMembers(mainActivity);
return mainActivity;
}

public static final class Builder {
private MainActivityMole mainActivityMole;
private AppServiceMole appServiceMole;

private Builder() {
}

public MainActivityComponent build() {
if (mainActivityMole == null) {
throw new IllegalStateException("mainActivityMole must be set");
}
if (appServiceMole == null) {
this.appServiceMole = new AppServiceMole();
}
return new DaggerMainActivityComponent(this);
}

public Builder mainActivityMole(MainActivityMole mainActivityMole) {
if (mainActivityMole == null) {
throw new NullPointerException("mainActivityMole");
}
this.mainActivityMole = mainActivityMole;
return this;
}

public Builder appServiceMole(AppServiceMole appServiceMole) {
if (appServiceMole == null) {
throw new NullPointerException("appServiceMole");
}
this.appServiceMole = appServiceMole;
return this;
}
}
}

这里面有两个类，一个是DaggerMainActivityComponent,另一个是Build类，Build中就是几个模块的初始化以及build方法构建DaggerMainActivityComponent类并初始化。DaggerMainActivityComponent类中定义了很多provider成员，这些成员就是Mole中提供的一些provider方法，还有其中的一些成员方法中的参数，那么这些各个类构造函数是怎么调用的呢，其实，我们Mole中每一个定义的provide方法，都会生成一个MainActivityMole_类似的类

[java] view plain print?
package com.example.lwp.mvp.ui.activity.mole;

import com.example.lwp.mvp.model.User;
import com.example.lwp.mvp.ui.activity.MainActivity;
import com.example.lwp.mvp.ui.activity.presenter.MainActivityPresenter;
import dagger.internal.Factory;
import javax.annotation.Generated;
import javax.inject.Provider;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class MainActivityMole_ implements Factory<MainActivityPresenter> {
private final MainActivityMole mole;
private final Provider<MainActivity> mainActivityProvider;
private final Provider<User> userProvider;

public MainActivityMole_(MainActivityMole mole, Provider<MainActivity> mainActivityProvider, Provider<User> userProvider) {
assert mole != null;
this.mole = mole;
assert mainActivityProvider != null;
this.mainActivityProvider = mainActivityProvider;
assert userProvider != null;
this.userProvider = userProvider;
}

@Override
public MainActivityPresenter get() {
MainActivityPresenter provided = mole.provideMainActivityPresenter(mainActivityProvider.get(), userProvider.get());
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
}
return provided;
}

public static Factory<MainActivityPresenter> create(MainActivityMole mole, Provider<MainActivity> mainActivityProvider, Provider<User> userProvider) {
return new MainActivityMole_(mole, mainActivityProvider, userProvider);
}
}
可以看到，这里面在需要MainActivityPresenter时候可以调用它的get方法，MainActivityPresenter的构造函数依赖另外两个对象，我们看他们其中他一个的Factory函数

[java] view plain print?
package com.example.lwp.mvp.ui.activity.mole;

import com.example.lwp.mvp.ui.activity.MainActivity;
import dagger.internal.Factory;
import javax.annotation.Generated;

@Generated("dagger.internal.codegen.ComponentProcessor")
public final class MainActivityMole_ProvideMainActivityFactory implements Factory<MainActivity> {
private final MainActivityMole mole;

public MainActivityMole_ProvideMainActivityFactory(MainActivityMole mole) {
assert mole != null;
this.mole = mole;
}

@Override
public MainActivity get() {
MainActivity provided = mole.provideMainActivity();
if (provided == null) {
throw new NullPointerException("Cannot return null from a non-@Nullable @Provides method");
}
return provided;
}

public static Factory<MainActivity> create(MainActivityMole mole) {
return new MainActivityMole_ProvideMainActivityFactory(mole);
}
}
这是MainActivity的Provider，可以看到它的get函数最后调用了mole也就是MainActivityMole中的provideMainActivity，这里就直接返回了一个MainActivity，所以，如果我们的构造函数中含有参数，dragger也会调用相应参数的Provider的Facory来生成相应的参数

从这里也可以看出这些类之间的构造依赖不能构成环路。

}

⑥ GitHub上面有哪些经典的java框架源码

⑦ Kotlin怎样使用Android的Dagger2

在Android Studio中打开Settings，选择Plugins选项，点击Browse Repositories，在打开的新窗口中搜索Kotlin，如下图所示。

选择Kotlin与 Kotlin Extenslons For Android(obsolete)两个插件分别进行安装。当插件安装完毕后，重启Android Studio即可。
在Android Studio中使用Kotlin插件
打开Android Studio新建一个项目，和往常一样建立一个项目就可以了，项目建立好以后，我们会在右键菜单New下看到多出来Kotlin File/Class和Kotlin Activity两个选项。
- Kotlin File/Class：一个普通的Kotlin类，类似普通的Java类
- Kotlin Actiivty：一个Activity类
安卓巴士有你更精彩！
入驻安卓巴士论坛，更多优质博文和精品源码等你！

⑧ android开发要不要用dagger2

用Dagger2在Android中实现依赖注入
依赖注入这个模式（模式已经用烂了，这里再烂一次）是用来给应用的各部分解耦的。使应用开发更加可扩展，更容易维护。通过本文你会学到如何使用Dagger2来处理依赖。
简介
如果以对象需要另外的一个对象才能完成一个完整功能的话，那么这里就存在一个依赖。比如，悟空要用金箍棒才能三打白骨精，要筋斗云才能十万八千里。悟空有对金箍棒和筋斗云的依赖。你可以在悟空对象里初始化金箍棒，也可以用一个工厂方法批量生产金箍棒。使用依赖注入可以无需一个专门的类来初始化这些依赖对象。这样就实现了解耦。
本教程会使用最新的Dagger2（当前的版本是2.2）。这里是官网。你可以在这里找到最新的发布。
准备
Android Studio是必须的。其他：
1. Dagger2 基础
注解讲解：
@Mole这个annotation修饰的类专门用来提供依赖
@Provides这个annotation修饰的方法用在Mole类里
@Inject用来annotation一个依赖（可以是构造方法、field或者一般的方法）
@Component连接@Mole和注入的桥梁
这些名词看起来非常抽象。下面稍微解释一下。依赖反射并没有什么神奇的地方。只不过是我们需要单独写初始化依赖的地方由其他的框架代替了。这个依赖关系也有我们常写的代码转移到了“配置文件”中。
在很久以前，依赖注入的框架就是这样处理依赖注入的：读取配置文件的依赖关系，然后用反射的方法初始化被依赖对象并赋值给调用依赖的对象。比如，我们之前在悟空类中初始化金箍棒：
public class Wukong {
private Jingubang jingubang;

public Wukong(){
// 依赖
this.jingubang = Jingubang();
}
}

后来有了使用配置文件的依赖注入（这里都是虚构的文件格式）：
<xml>
<com.xiyou.Wukong>
<dependency field="jingubang">
<com.xiyou.Jingubang />
</dependency>
</com.xiyou.Wukong>
</xml>

在悟空使用金箍棒的时候，依赖注入框架自动初始化好了金箍棒，并赋值给了悟空。
现在使用Dagger2。这里就有不得不说的牛X的地方了。因为是在Android里能用的资源没有后端那么多。尤其反射消耗比较大！所以Dagger为了满足移动开发节约资源的需要，没有使用反射实现依赖注入。而是在编译的时候同时生成依赖注入的相关代码。生成代码的根据就是前文中说明的那些注解（annotation）以及使用这些annotation的类、接口。
总结起来就一句话，Dagger把你需要在悟空类里写的金箍棒类的初始化代码都根据注解替你自动生成了！只不过这种生成的代码比明晃晃的使用new初始化的方法更加复杂一些。
Dagger2 开发步骤
把大象装冰箱一共分几步：
定义依赖和被依赖的对象的类，悟空类和金箍棒类。“悟空类”和“金箍棒类”的构造函数用@Inject注解修饰。
定义一个@Mole注解的类，一般叫做XXXMole。里面写的@Provides注解修饰的方法。这些@Provides方法返回“悟空类”和“金箍棒类”对象。比如@Provides Wukong provideWukong(){ return new Wukong(); }
创建一个interface，并用@Component注解修饰。一般叫做XXXComponent。里面写一个注入方法：void inject(Wukong wk);。这里Wukong只是一个例子。任何你准备要注入的类都可以代替上面参数的Wukong类。
在需要注入的地方写@Inject的field。
最后，Dagger会根据上面的内容和最后的@Component接口生成一个DaggerXXXComponent的类型，使用这个类型来实现注入。上面的1到3步可以理解为依赖的配置。最后的XXXComponent代替古老的Reflect方式实现注入。
第一步的@Inject修饰的构造函数和`@Mole`的`provideXXX`方法二者可以省略一个。
Dagger可以根据其中的任意一种配置创建依赖的对象。都写上等于有了双保险。

上文提到过多次。Dagger 2厉害的地方就在于这个库完全不用反射，而是用在编译期生成代码的方式实现的依赖注入。这个特点导致在Android Studio配置的时候需要做一些额外的工作。
这里假设你已经创建了一个新的Android应用项目。下面打开build.gradle文件，我们一步一步的来完成Dagger2的配置。
3. Android Studio的配置
第一步、
apply plugin: 'kotlin-android' // 非必须
apply plugin: 'kotlin-android-extensions' // 必须！！！

为什么要加一个新的plugin呢？这个是为后面使用的kapt和provided提供支持的。gradle本身不支持这两个操作。
第二步、
buildscript {
ext.kotlin_version = '1.0.1-2'
repositories {
mavenCentral()
}
dependencies {
classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
classpath "org.jetbrains.kotlin:kotlin-android-extensions:$kotlin_version"
}
}

第三步、
dependencies {
// ...其他略...
compile 'com.google.dagger:dagger:2.2'
kapt 'com.google.dagger:dagger-compiler:2.2'
provided 'javax.annotation:jsr250-api:1.0'
}

dagger, 我们要用的正主。
dagger-compiler, 用来生成代码。
java.annotation, 提供Dagger意外的注解
最后，同步Gradle。
使用Dagger 2
下面就是Dagger一展身手的时候了。
首先，我们已经有悟空和金箍棒了。代码如下：
悟空：
import javax.inject.Inject;

/**
* Created by uncle_charlie on 6/4/2016.
*/
public class Wukong {

@Inject
JinGuBang jinGuBang;

@Inject
public Wukong() {

}

public String useJinGuBang() {
return this.jinGuBang.use();
}
}

金箍棒：
import javax.inject.Inject;

/**
* Created by uncle_charlie on 6/4/2016.
*/
public class JinGuBang {

@Inject
public JinGuBang() {

}

public String use() {
return "user Jing gu bang";
}
}

悟空对金箍棒有依赖，所以金箍棒属性有@Inject注解修饰。
因为两个类都需要Dagger创建，所以在构造函数上都有@Inject注解。
第二步、创建@Mole类
创建@Mole注解的类，并在其中添加@Provides注解修饰的方法。这些方法创建被依赖的对象。
import dagger.Mole;
import dagger.Provides;

/**
* Created by uncle_charlie on 6/4/2016.
*/
@Mole
public class XiYouMole {
@Provides
// @Singleton
Wukong provideWukong() {
return new Wukong();
}

@Provides
// @Singleton
JinGuBang provideJinGuBang() {
return new JinGuBang();
}
}

@Singleton注解表明，这个被依赖的对象在应用的生命周期里只有一个实例。
这个里的@Provides方法和前一步说到的@Inject注解的构造函数两个可以只写一个。
第三步、@Component接口，连接@Mole和@Inject
@Mole和@Provides方法提供了被依赖的对象。@Inject在@Component接口出现的地方则是指明了需要注入的地方（一般是一个field）。@Component接口就是用来把他们连接起来的。
import android.app.Activity;
import javax.inject.Singleton;
import dagger.Component;

/**
* Created by uncle_charlie on 6/4/2016.
*/
@Component(moles = {XiYouMole.class})
@Singleton
public interface XiYouComponent {
void inject(Wukong wk);
void inject(Activity a);
}

其中inject()方法里使用的对象，就是包含@Inject的field的需要注入的对象。
在这个接口中也可以不用inject()方法，而使用provideXXX()方法后面会有更多介绍。
注意：@Component接口一定要在直接中指明@Mole类型

第四步、使用@Component接口获取对象
经过前面的步骤，依赖和被依赖对象关系都已经配置好了。下面就来获取被依赖对象来注入依赖对象。
public class MainActivity extends AppCompatActivity {
private static final String TAG = "##MainActivity";

@Inject
Wukong wukong;

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

TextView welcomeTextView = (TextView) findViewById(R.id.welcome_textview);
// 1
XiYouComponent xiYouComponent = DaggerXiYouComponent
.builder()
// 2
.xiYouMole(new XiYouMole())
.build();
xiYouComponent.inject(this);
// 3
welcomeTextView.setText(wukong.useJinGuBang());
}
}

首先主要到属性@Inject Wukong wukong;已经在MainActivity声明了。这里表明一个依赖关系：这个activity依赖于悟空，并准备注入悟空对象。
Dagger2会在编译器自动生成依赖注入的代码，所以在添加上面的代码之前需要编译一下。DaggerXiYouComponent就是Dagger根据我们的XiYouMole类生成的代码。
在这一步给DaggerXiYouComponent的builder添加XiYouMole的实例。如果这个Mole只需要用到无参构造函数的话可以用一种省略用法：create()方法。可以简写为：
DaggerXiYouComponent
.builder()
// 2
//.xiYouMole(new XiYouMole())
//.build()
.create();

Component接口的对象调用inject(this)方法之后注入即完成。所以可以直接使用@Inject Wukong wukong;属性来调用方法：welcomeTextView.setText(wukong.useJinGuBang());最后在activity中显示方法返回的文字。
运行代码，看看结果吧。
结论
以上内容可以概括为：什么被依赖，就把什么放在@Mole类里（或者什么被依赖，就给什么添加@Inject的无参构造函数）。什么有依赖（@Inject属性），就把什么放在@Component接口的inject()方法参数里。（或者有什么@Inject属性，就在@Component接口里provide什么对象）。这个概括不一定严密，但是基本用法全部包括了。
依赖注入是很有用的。以上的内容只是Dagger2依赖注入的一部分。各位读者还需要根据官方文档多加练习才能更好的理解依赖注入和Dagger的各种用法。

⑨ 学习dagger2需要什么基础

3. the narrative through brand enhancing brand asset value A community has a good reputation, in the market for good performance of the brand, it must be a branding element is complete, make a good impression and aftertaste of 。

阅读全文

与dagger2源码讲解相关的资料

热点内容
喷油螺杆制冷压缩机 浏览：577
python员工信息登记表 浏览：375
高中美术pdf 浏览：158
java实现排列 浏览：511
javavector的用法 浏览：979
osi实现加密的三层 浏览：230
大众宝来原厂中控如何安装app 浏览：911
linux内核根文件系统 浏览：240
3d的命令面板不见了 浏览：523
武汉理工大学服务器ip地址 浏览：146
亚马逊云服务器登录 浏览：522
安卓手机如何进行文件处理 浏览：70
mysql执行系统命令 浏览：928
php支持curlhttps 浏览：142
新预算法责任 浏览：443
服务器如何处理5万人同时在线 浏览：249
哈夫曼编码数据压缩 浏览：424
锁定服务器是什么意思 浏览：383
场景检测算法 浏览：616
解压手机软件触屏 浏览：348
  • 都市寻花录全文阅读
  • 火影忍鸣人x纲手黄漫
  • 玉米地里的刘春妮
  • 情侣在宾馆在线播放
  • 浪花一朵朵mv
  • 藤梨根的功效与作用
  • 电视剧美好生活
  • 预备警官
  • 色欲世代
  • 金刚1933版
  • 美国队长3高清免费观看
  • 外星女生柴小七电视剧
  • 死亡片场哪个网可以看
  • 亚洲狼人第一综合网站
  • 吕良伟包青天95版全集
  • 深田咏美整容
  • 没有心跳的少女免费观看
  • 任你躁在线视频
  • yy4138殇情影院苹果
  • 生活大爆炸第六季在线观看
  • 香港解密
  • 可以看电影的网站
  • 惩戒师的管教惩罚
  • 印度电影排行榜
  • 蜡笔小新5季
  • 逃学外传
  • 我在女寝室一个一个上
  • 幸福加油站免费视频
  • aletta ocean blog
  • 电视剧打狗棍
  • 《浮生一世》墨宝非宝
  • 二攻一受同时做 双头龙
  • 积高侠
  • 月亮坪的秘密
  • 中国好声音第三季富九
  • 极乐盒子资源网站
  • 向往的生活第二季免费观看
  • 书耽网免费破解连接
  • 抓着她的丰盈顶了进去
  • 星际共妻强制多夫
  • 爸爸我们去哪儿
  • 崩坏三本子无翼鸟
  • 空姐视频
  • 阳光电影天堂
  • 3d图纸布衣图今天
  • 那些爱过的人
  • 世界的尽头
  • 学而思客服电话
  • 魔法科
  • 红电视剧在线观看
  • 拯救爱情
  • 搜索电影结局
  • 安子轩20以下禁止进入
  • jiz中国zz免费版
  • 抗倭侠侣第二季
  • 韩国女主播19tv免费版
  • 篮球火1
  • 我说的都是真的在线播放
  • 绝地逃亡粤语
  • 有喜欢的人
  • 2017最新国产小视频
  • 同床异梦第二季在线观看
  • 绯红女巫
  • 我是你爸爸电影
  • 义 母 的吐 息 在线观看
  • 人间至味
  • 星际之门起源
  • 1st kiss快看漫画
  • 尤蜜app
  • 小黄山
  • 金牌律师美剧
  • 手机岛国3d片源网址
  • 不是机器人韩剧剧情
  • 完美的他人
  • 降魔转国语在线播放
  • 米子电影官网
  • 韩国漫画亲亲漫画网
  • 有一款软件叫香蕉什么
  • 艾薇拉
  • 王栎鑫综艺
  • 我爱52v52v好色
  • 特种神枪手电影
  • 驯龙高手1电影
  • 不汗党电影
  • 流氓大亨粤语版
  • 脱狱
  • 电车系列
  • 深田绘美车牌miaa024
  • ck电影网2018手机版官网
  • 致我们单纯的小美好在线免费观看
  • 被大狼狗进入的时候
  • 男人最爱看免费网站
  • 亲爱的热爱的免费在线看
  • 我愿意电影在线看
  • 大逃脱 免费在线观看
  • 魅者无疆电视剧
  • 国家宝藏第四期
  • 窥视者第二季96话
  • 豪放女大兵女手机播放
  • 大约是爱百度云资源