一.什么是设计模式
1.解决特定的问题，管理Activity，单例设计模式，recyclerview 添加头部和底部，装饰设计模式
2.有利于代码的规范，让代码更灵活
3.有利于我们的开发，提高开发效率。
个人理解：玩一些套路，23种
二.我们讲解一下模板设计模式
通俗点的理解就是 ：完成一件事情，有固定的数个步骤，但是每个步骤根据对象的不同，而实现细节不同；就可以在父类中定义一个完成该事情的总方法，按照完成事件需要的步骤去调用其每个步骤的实现方法。每个步骤的具体实现，由子类完成。
三、简单实现的介绍
package com.dp.example.templatemethod;
/**
* 抽象的Computer
* @author wulafu
*
*/
public abstract class AbstractComputer {
protected void powerOn() {
System.out.println("开启电源");
}
protected void checkHardware() {
System.out.println("硬件检查");
}
protected void loadOS() {
System.out.println("载入操作系统");
}
protected void login() {
System.out.println("小白的电脑无验证，直接进入系统");
}
/**
* 启动电脑方法, 步骤固定为开启电源、系统检查、加载操作系统、用户登录。该方法为final， 防止算法框架被覆写.
*/
public final void startUp() {
System.out.println("------ 开机 START ------");
powerOn();
checkHardware();
loadOS();
login();
System.out.println("------ 开机 END ------");
}
}
package com.dp.example.templatemethod;
/**
* 码农的计算机
*
* @author wulafu
*/
public class CoderComputer extends AbstractComputer {
@Override
protected void login() {
System.out.println("码农只需要进行用户和密码验证就可以了");
}
}
package com.dp.example.templatemethod;
/**
* 军用计算机
*
* @author wulafu
*/
public class MilitaryComputer extends AbstractComputer {
@Override
protected void checkHardware() {
super.checkHardware();
System.out.println("检查硬件防火墙");
}
@Override
protected void login() {
System.out.println("进行指纹之别等复杂的用户验证");
}
}
package com.dp.example.templatemethod;
public class Test {
public static void main(String[] args) {
AbstractComputer comp = new CoderComputer();
comp.startUp();
comp = new MilitaryComputer();
comp.startUp();
}
}复制代码------ 开机 START ------
开启电源
硬件检查
载入操作系统
码农只需要进行用户和密码验证就可以了
------ 开机 END ------
------ 开机 START ------
开启电源
硬件检查
检查硬件防火墙
载入操作系统
进行指纹之别等复杂的用户验证
------ 开机 END ------复制代码通过上面的例子可以看到，在startUp方法中有一些固定的步骤，依次为开启电源、检查硬件、加载系统、用户登录四个步骤，这四个步骤是电脑开机过程中不会变动的四个过程。但是不同用户的这几个步骤的实现可能各不相同，因此他们可以用不同的实现。而startUp为final方法，即保证了算法框架不能修改，具体算法实现却可以灵活改变。startUp中的这几个算法步骤我们可以称为是一个套路，即可称为模板方法。因此，模板方法是定义一个操作中的算法的框架，而将一些步骤延迟到子类中。使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。如图 :
四. Android源码中的模式实现
在Android中，使用了模板方法且为我们熟知的一个典型类就是AsyncTask了，关于AsyncTask的更详细的分析请移步Android中AsyncTask的使用与源码分析，我们这里只分析在该类中使用的模板方法模式。
在使用AsyncTask时，我们都有知道耗时的方法要放在doInBackground(Params... params)中，在doInBackground之前如果还想做一些类似初始化的操作可以写在onPreExecute方法中，当doInBackground方法执行完成后，会执行onPostExecute方法，而我们只需要构建AsyncTask对象，然后执行execute方法即可。我们可以看到，它整个执行过程其实是一个框架，具体的实现都需要子类来完成。而且它执行的算法框架是固定的，调用execute后会依次执行onPreExecute,doInBackground,onPostExecute,当然你也可以通过onProgressUpdate来更新进度。我们可以简单的理解为如下图的模式 :
下面我们看源码，首先我们看执行异步任务的入口, 即execute方法 :
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("Cannot execute task:"
+ " the task is already running.");
case FINISHED:
throw new IllegalStateException("Cannot execute task:"
+ " the task has already been executed "
+ "(a task can be executed only once)");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
复制代码mWorker和mFuture又是什么呢？其实mWorker只是实现了Callable接口，并添加了一个参数数组字段，我们挨个来分析吧，跟踪代码我们可以看到，这两个字段都是在构造函数中初始化。
public AsyncTask() {
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
return postResult(doInBackground(mParams));
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
final Result result = get();
postResultIfNotInvoked(result);
} catch (InterruptedException e) {
android.util.Log.w(LOG_TAG, e);
} catch (ExecutionException e) {
throw new RuntimeException("An error occured while executing doInBackground()",
e.getCause());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
} catch (Throwable t) {
throw new RuntimeException("An error occured while executing "
+ "doInBackground()", t);
}
}
};
}
复制代码简单的说就是mFuture就包装了这个mWorker对象，会调用mWorker对象的call方法，并且将之返回给调用者。关于AsyncTask的更详细的分析请移步Android中AsyncTask的使用与源码分析，我们这里只分析模板方法模式。总之，call方法会在子线程中调用，而在call方法中又调用了doInBackground方法，因此doInBackground会执行在子线程。doInBackground会返回结果，最终通过postResult投递给UI线程。 我们再看看postResult的实现 :
private Result postResult(Result result) {
Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
private static class InternalHandler extends Handler {
@SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
@Override
public void handleMessage(Message msg) {
AsyncTaskResult result = (AsyncTaskResult) msg.obj;
switch (msg.what) {
case MESSAGE_POST_RESULT:
// There is only one result
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
复制代码可以看到，postResult就是把一个消息( msg.what == MESSAGE_POST_RESULT)发送给sHandler，sHandler类型为InternalHandler类型，当InternalHandler接到MESSAGE_POST_RESULT类型的消息时就会调用result.mTask.finish(result.mData[0])方法。我们可以看到result为AsyncTaskResult类型，源码如下 :
@SuppressWarnings({"RawUseOfParameterizedType"})
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
复制代码可以看到mTask就是AsyncTask对象，调用AsyncTask对象的finish方法时又调用了onPostExecute，这个时候整个执行过程就完成了。 总之，execute方法内部封装了onPreExecute, doInBackground, onPostExecute这个算法框架，用户可以根据自己的需求来在覆写这几个方法，使得用户可以很方便的使用异步任务来完成耗时操作，又可以通过onPostExecute来完成更新UI线程的工作。
另一个比较好的模板方法示例就是Activity的声明周期函数，例如Activity从onCreate、onStart、onResume这些程式化的执行模板，这就是一个Activity的模板方法。
五. 构建整个应用的BaseActivity
接下来我们看一下怎么才能用到开发中... 等等我要去举报你 --> 怎么啦？ 你抄袭别人的。怎么？被发现了吗，我这不是抄袭只是把好东西拿出来与大家分享而已，给大家推荐一下：github.com/simple-andr… 里面有很多设计模式，最好大家可以买一本书看一下这么好的东西还是支持一下吧希望可以出一些更好的（虽然我看的是电子文档）。说到这里非常感谢大家的打赏虽然不多但是我内心真的很感谢，希望以后可以出更多好的文章。
在网上查了很多关于别人讲的模板设计模式，都是只简单的介绍一下概念然后写一个小的事例如：程序员的一天，银行办理业务等等等等。我最近剃了个光头，因为上班闲来无事看别人的博客的时候老是抓头发，一直都在想想我该用到哪里呢？哪里又能用到呢？.......所以干脆剃了个光头。
因为目前还是停留在内涵段子项目的系统架构部分，而且每个项目肯定离不开Activity，在Activity的onCreate()方法里面基本都是：设置布局 ->初始化头部 -> 初始化界面 -> 初始化数据。如果按照这么个流程是不是刚好符合我们模板设计模式。
/**
* Created by wulafu on 2019/2/8.
* Description: 整个应用的BaseActivity
*/
public abstract class BaseActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView();
initTitle();
initView();
initData();
}
// 初始化数据
protected abstract void initData();
// 初始化界面
protected abstract void initView();
// 设置界面视图
protected abstract void setContentView();
// 初始化头部
protected abstract void initTitle();
}
复制代码以后我们每次新建Activity就不会直接继承自 AppCompatActivity 而是我们自己的BaseActivity就会自动要我们复写BaseActivity里面的几个抽象方法，我们在方法里面写对应的代码。
/**
* Created by wulafu on 2019/2/8.
* Description: 主页面MainActivity
*/
public class MainActivity extends BaseActivity {
@Override
protected void initData() {
}
@Override
protected void initView() {
}
@Override
protected void setContentView() {
setContentView(R.layout.activity_main);
}
@Override
protected void initTitle() {
}
}
复制代码这也没见到什么好处啊~好处我待会再来说，我们先对BaseActivity来扩展一下，一些通用的流程和功能其实可以放在BaseActivity里面，比如前几次所分享的自己动手打造一套IOC注解框架、启动Activity...
/**
* Created by wulafu on 2019/2/8.
* Description: 整个应用的BaseActivity
*/
public abstract class BaseActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView();
// IOC注解注入
ViewUtils.inject(this);
initTitle();
initView();
initData();
}
// 初始化数据
protected abstract void initData();
// 初始化界面
protected abstract void initView();
// 设置界面视图
protected abstract void setContentView();
// 初始化头部
protected abstract void initTitle();
/**
* 启动一个Activity
* @param activity 需要启动的Activity的Class
*/
public void startActivity(Class<? extends Activity> activity) {
Intent intent = new Intent(this,activity);
startActivity(intent);
}
/**
* findViewById 不需要再去强转
*/
public <T extends View> T viewById(@IdRes int resId) {
return (T) super.findViewById(resId);
}
}
复制代码接下来我们来说一下好处，模板设计模式的好处就不说了网上太多了，我们就只说在真正的开发中这么做的好处
- 在实际的开发过程中我们往往不是一个人在开发，如果把直接在onCreate()里面写很多东西显然不行，但是如果写一些方法，那么每个成员所写的方法都会不同，何况有些哥们英语估计没过四级，单词都写错；
- 直接继承自BaseActivity会自动提示覆盖方法，更加有利于开发或者代码的阅读，每个方法各尽其职只干自己该干的事，没事干就歇着；
- 我们可以把通用的流程或者是某些方法放到BaseActivity，这样又节省代码又方便但是不是乱七八糟的放一大堆，细节会有很多具体可以看视频讲解；
- 我们中间肯定还需要逻辑层的BaseActivity，这样做其实有利于后期的版本迭代、层次抽离和代码重构...
六.JAVA线程中的模板设计模式
作为一名java程序员，创建线程是工作中经常干的事情，也是面试中经常被提问的问题。大家都知道java中创建线程有两种最基本的方式： 创建Thread类； 实现runnable借口； 这两种方式有一个共同点就是我们的业务逻辑必须要实现run()这个方法,然后我们调用start()方法来启动线程。跟踪Thread的start()方法源码我们可以看到：
public synchronized void start() {
/**
* This method is not invoked for the main method thread or "system"
* group threads created/set up by the VM. Any new functionality added
* to this method in the future may have to also be added to the VM.
*
* A zero status value corresponds to state "NEW".
*/
if (threadStatus != 0)
throw new IllegalThreadStateException();
/* Notify the group that this thread is about to be started
* so that it can be added to the group's list of threads
* and the group's unstarted count can be decremented. */
group.add(this);
boolean started = false;
try {
start0();
started = true;
} finally {
try {
if (!started) {
group.threadStartFailed(this);
}
} catch (Throwable ignore) {
/* do nothing. If start0 threw a Throwable then
it will be passed up the call stack */
}
}
复制代码
start()方法调用了一个start0()方法,而start0()方法源码如下：
private native void start0();
/**
* If this thread was constructed using a separate
* <code>Runnable</code> run object, then that
* <code>Runnable</code> object's <code>run</code> method is called;
* otherwise, this method does nothing and returns.
* <p>
* Subclasses of <code>Thread</code> should override this method.
*
* @see #start()
* @see #stop()
* @see #Thread(ThreadGroup, Runnable, String)
*/
@Override
public void run() {
if (target != null) {
target.run();
}
}复制代码start0是一个native修饰的方法，而且它调用了run(),其实一点从设计模式上不能理解，这里用到的就是一个简单的模板模式，目的就是为了让业务的逻辑和线程的逻辑分离。以下是模板模式模拟线程的实现，希望有助于理解模板模式在Thread中的应用
/**
* Description
* <p>
* </p>
* DATE 2019/10/1.
*
* @author wulafu.
*/
public class Template {
public Template() {
}
public final void start(){
System.out.println("stat方法启动！");
run();
System.out.println("start方法结束！");
}
public void run(){}
public static void main(String[] args) {
Template template = new Template(){
@Override
public void run() {
System.out.println("run方法开始运行！");
}
};
template.start();
}
复制代码运行结果：
stat方法启动！
run方法开始运行！
start方法结束！
扫一扫
453
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
