1.1完成音乐播放布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/play_layout"
    android:orientation="vertical"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#e0e0e0"
    tools:context="com.example.administrator.huntermusic.activity.AudioPlayActivity">
    <TextView
        android:id="@+id/music_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:layout_gravity="center"
        android:text="歌曲名"
        android:textSize="20sp"
        android:layout_marginTop="30dp"/>
    <TextView
        android:id="@+id/singer_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="歌手"
        android:layout_margin="5dp"
        android:layout_gravity="center"
        android:gravity="center"/>
    <com.example.administrator.huntermusic.utils.CDView
        android:id="@+id/CD_view"
        android:layout_marginBottom="80dp"
        android:layout_marginTop="50dp"
        android:layout_width="200dp"
        android:layout_height="200dp"
        android:layout_gravity="center">
    </com.example.administrator.huntermusic.utils.CDView>
    <TextView
        android:id="@+id/tv_position"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="right"
        android:text="00:00/00:00"
        android:textSize="15sp"
        android:layout_margin="10dp"
        />
    <SeekBar
        android:id="@+id/seekbar"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="6dp"
        android:layout_marginLeft="4dp"
        android:layout_marginRight="4dp"
        android:layout_margin="20dp"
        android:progress="0"
        android:thumbOffset="0dp"
        />
    <LinearLayout
        android:orientation="vertical"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:layout_marginTop="4dp"
        >
        <LinearLayout
            android:orientation="horizontal"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:gravity="center">
            <ImageView
                android:id="@+id/play_mode"
                android:layout_width="32dp"
                android:layout_height="wrap_content"
                android:layout_gravity="center"
                android:layout_margin="10dp"
                />
            <ImageView
                android:id="@+id/pre"
                android:layout_width="32dp"
                android:layout_height="wrap_content"
                android:layout_gravity="center"
                android:layout_margin="10dp"
                android:background="@drawable/pre"/>
            <ImageView
                android:id="@+id/play"
                android:layout_width="64dp"
                android:layout_height="wrap_content"
                android:layout_margin="10dp"
                />
            <ImageView
                android:id="@+id/next"
                android:layout_width="32dp"
                android:layout_height="wrap_content"
                android:layout_gravity="center"
                android:layout_margin="10dp"
                android:background="@drawable/next"/>
            <ImageView
                android:id="@+id/playlist"
                android:layout_width="32dp"
                android:layout_height="wrap_content"
                android:layout_gravity="center"
                android:layout_margin="10dp"
                android:background="@drawable/playlist"/>
        </LinearLayout>
    </LinearLayout>
</LinearLayout>

其中的CDView可以先使用一个ImageView来代替，之后我们再慢慢完善。最终效果如下：

1.2播放音乐

播放音乐需要在服务中播放，因为在退出界面的时候，音乐还在播放，这导致音乐的不可控制。所以为了便于控制我们将播放的逻辑放在服务中。那么就需要将数据也传递到服务中。

AudioPlayActivity .java

package com.example.administrator.huntermusic.activity;

import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.content.res.Resources;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.view.Window;


public class AudioPlayActivity extends AppCompatActivity implements View.OnClickListener{

    private AudioServiceConnection audioServiceConnection;
    private AudioPlayService.AudioBinder binder;


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_audio_play);
        initData();
        initView();

    }

    @Override
    protected void onDestroy(){
        super.onDestroy();
        unbindService(audioServiceConnection);

    }

    public void initData(){
        Intent service = new Intent(getIntent());
        service.setClass(this, AudioPlayService.class);
        audioServiceConnection = new AudioServiceConnection();
        bindService(service, audioServiceConnection, BIND_AUTO_CREATE);
        startService(service);
    }





    public class AudioServiceConnection implements ServiceConnection {
        @Override
        public void onServiceConnected(ComponentName name, IBinder iBinder) {
               binder = (AudioPlayService.AudioBinder) iBinder;
        }
        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    }
}

在服务中播放音乐

AudioPlayService .java

package com.example.administrator.huntermusic.service;

import android.app.Service;
import android.content.Intent;
import android.media.MediaPlayer;
import android.net.Uri;
import android.os.Binder;
import android.os.IBinder;
import com.example.administrator.huntermusic.bean.AudioItem;
import java.io.IOException;


public class AudioPlayService extends Service {
    private AudioBinder binder;
    private List<AudioItem> audioItemList;
    private int position;

    @Override
    public IBinder onBind(Intent intent) {
        binder = new AudioBinder();
        return binder;
    }

    @Override
    public void onCreate() {
        super.onCreate();

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        audioItemList = (List<AudioItem>) intent.getSerializableExtra("audioItems");
        position = intent.getIntExtra("position", -1);
        binder.play();
        return super.onStartCommand(intent, flags, startId);
    }

    @Override
    public boolean onUnbind(Intent intent) {
        return super.onUnbind(intent);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
    }



    public class AudioBinder extends Binder{
        private MediaPlayer media_player;
        public void play(){
            if (media_player!=null){
                media_player.reset();
                media_player.release();
                media_player  = null;

            }
            AudioItem audioItem = audioItemList.get(position);
            media_player = new MediaPlayer();
            backIsPlay = true;
            try {
                media_player.setDataSource(AudioPlayService.this, Uri.parse(audioItem.getPath()));
                media_player.prepare();
                media_player.setOnPreparedListener(new OnAudioPreparedListener(media_player.getCurrentPosition()));
                media_player.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
    }
}

1.3 完成界面功能

1.3.1在 AudioBinder 中提供音乐暂停开始的方法。在AudioPlayActivity 中点击开始按钮调用暂停开始的方法。

public void pause(){
            media_player.pause();
            backIsPlay = false;
        }
public void start(){
            media_player.start();
            backIsPlay = true;
        }
public boolean isPlaying(){
            return media_player.isPlaying();
        }

AudioPlayActivity 继承View .OnClickListener接口，在 AudioPlayActivity 中调用开始暂停播放的方法

@Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.play :
                switchPlayState();
                break;
    }
    private void switchPlayState() {
        if (binder.isPlaying()){
            binder.pause();
            }else{
            binder.start();
        }
        updataPlayButton();
         }

更新播放按钮

private void updataPlayButton(){
        if (binder.isPlaying()) {
            play_button.setImageResource(R.drawable.pause_shadow);
        } else {
            play_button.setImageResource(R.drawable.play_shadow);
        }
    }

当音乐准备完成后需要改变界面按钮的状态为暂停按钮，并且初始化接收到的歌曲名和歌手名。在服务中发送广播，在界面中注册广播之后更新界面。

public class AudioBinder extends Binder{
        private MediaPlayer media_player;
        public void play(){
            if (media_player!=null){
                media_player.reset();
                media_player.release();
                media_player  = null;

            }
            AudioItem audioItem = audioItemList.get(position);
            media_player = new MediaPlayer();
            backIsPlay = true;
            try {
                media_player.setDataSource(AudioPlayService.this, Uri.parse(audioItem.getPath()));
                media_player.prepare();
                media_player.setOnPreparedListener(new OnAudioPreparedListener(media_player.getCurrentPosition()));
                media_player.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
            public void pause(){
            media_player.pause();
            backIsPlay = false;
        }
public void start(){
            media_player.start();
            backIsPlay = true;
        }
public boolean isPlaying(){
            return media_player.isPlaying();
        }

private class OnAudioPreparedListener implements MediaPlayer.OnPreparedListener{
            @Override
            public void onPrepared(MediaPlayer mp) {
            mp.start();
                Intent intent = new Intent("com.work.huntermusic.updateplaybtn");
                //获取当前正在播放的音乐
                AudioItem audioItem = audioItemList.get(position);
                intent.putExtra("audioItem",audioItem);
                sendBroadcast(intent);
            }
        }
}

在 AudioPlayActivity 中注册广播，更新界面

IntentFilter intentFilter = new IntentFilter("com.work.huntermusic.updateplaybtn");
        registerReceiver(new AudioBroadCastReceiver(), intentFilter);

private class AudioBroadCastReceiver extends BroadcastReceiver{
        @Override
        public void onReceive(Context context, Intent intent) {
            //更新界面的按钮
            updataPlayButton();
            AudioItem audioItem = (AudioItem) intent.getSerializableExtra("audioItem");
            music_name.setText(audioItem.getName());
            singer_name.setText(audioItem.getSinger());
     }
}        

1.3.2时间进度更新
在服务中的 AudioBinder中提供获取播放总时长和当前播放进度的方法， 当 MediaPlayer准备完成后播放界面收到广播发消息开始更新

在 AudioBinder 中提供获取总时长和当前播放进度的方法

/** 获取音乐的播放总时长*/
public int getDuration(){
            return media_player.getDuration();
        }
/** 获取音乐当前播放进度*/
public int getCurrentPosition(){
            return media_player.getCurrentPosition();
        }

在播放界面收到广播之后开始发消息更新

private class AudioBroadCastReceiver extends BroadcastReceiver{
        @Override
        public void onReceive(Context context, Intent intent) {
            //更新界面的按钮
            updataPlayButton();
            AudioItem audioItem = (AudioItem) intent.getSerializableExtra("audioItem");
            music_name.setText(audioItem.getName());
            singer_name.setText(audioItem.getSinger());
            //更新播放进度
            updateCurrentPosition();
     }
} 
public void updataCurrentPosition(){
        int duration=binder.getDuration();
        int position=binder.getCurrentPosition();
        seekbar.setMax(binder.getDuration());
        String durationStr= StringUtil.formatDuration(duration);
        String positionStr=StringUtil.formatDuration(position);
        tv_position.setText(positionStr + " / " + durationStr);
       handler.sendEmptyMessageDelayed(UPDATA_POSITION,500);
    }

    private static final int UPDATA_POSITION = 0;
    private Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            switch (msg.what){
                case UPDATA_POSITION:
                    updataCurrentPosition();
        break;

            }
        }
    };

这里给出StringUtil中时间转换的方法formatDuration（）

public static String formatDuration(int duration){
        int hour = 60*60*1000;
        int minute = 60*1000;
        int second = 1000;

        int ghour = duration/hour;
        int temp = duration%hour;

        int gminute = temp/minute;
        temp = temp%minute;

        int gsecond = temp/second;

        if (ghour==0){
            return String.format("%02d:%02d",gminute,gsecond);
        }else{
            return String.format("%02d:%02d:%2d",ghour,gminute,gsecond);
        }
    }

为了防止内存泄露，在界面销毁的时候也需要将消息都移除掉。

1.3.3时间进度条的实现

在播放页面收到广播之后给 SeekBar 进行设置最大进度，在更新播放进度的时候同时去更新当前进度并且滑动 SeekBar 的时候改变进度

设置当前播放进度

 /** 更新播放进度*/
 public void updateCurrentPosition() {
 int position=binder.getCurrentPosition();
 //及时更新进度时间
 updatePosition(position);
 handler.sendEmptyMessageDelayed(UPDATE_POSITION,500);
 }

滑动 SeekBar 的时候改变进度。在服务中提供改变进度的方法并且给 SeekBar 设置进度改变的监听

 seekbar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
                if (fromUser) {
                    binder.seekTo(progress);
                    updatePosition(progress);
                }
            }

            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {

            }

            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {
                binder.seekTo(seekBar.getProgress());
            }
        });

服务 AudioBinder 中的改变进度的方法

/** 进度跳转*/
 public void seekTo(int progress){
     mediaPlayer.seekTo(progress);
 }

1.3.4播放上一首和下一首

在 AudioBinder 中提供播放上一首和下一首的方法，当点击按钮的时候调用播放上一首和下一首的方法。注意：在播放的时候需要将之前的 mediaplayer 进行重置

        public void previous(){
            if (position!=0){
                position--;
                media_player.reset();
                play();
            }else {
                position = audioItemList.size()-1;
            }
        }
        public void next(){
            if (position!=audioItemList.size()-1){
                position++;
                media_player.reset();
                play();
            }else {
                position = 0;
            }
        }

然后在播放页面调用binder的方法前一首和后一首的方法

@Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.play :
                switchPlayState();
                break;
            case R.id.pre :
                binder.previous();
                break;
            case R.id.next :
                binder.next();
                break;

        }
    }

1.3.5切换播放模式

在 AudioBinder 中提供切换播放模式的方法和获取当前播放模式

    public static final int PLAY_ALL_REPEAT = 0;
    public static final int PLAY_RANDOM = 1;
    public static final int PLAY_SINGLE_REPEAT = 2;

    private int playMode = PLAY_ALL_REPEAT;
        public void changePlayMode(){
            if (playMode == PLAY_ALL_REPEAT){
                    playMode = PLAY_RANDOM;
            }else if (playMode ==PLAY_RANDOM) {
                playMode = PLAY_SINGLE_REPEAT;
            }else if (playMode ==PLAY_SINGLE_REPEAT){
                    playMode = PLAY_ALL_REPEAT;
            }
        }

在播放页面点击切换播放模式的图片

@Override
    public void onClick(View v) {
        switch (v.getId()){
            case R.id.play :
                switchPlayState();
                break;
            case R.id.pre :
                binder.previous();
                break;
            case R.id.next :
                binder.next();
                break;
            case R.id.play_mode:
                binder.changePlayMode();
                //及时更新播放模式
                updataPlayMode();
                break;
        }
    }

private void updataPlayMode() {
        switch (binder.getPlayMode()){
            case AudioPlayService.PLAY_ALL_REPEAT:
                play_mode.setImageResource(R.drawable.list_repeat);
                break;
            case AudioPlayService.PLAY_RANDOM:
                play_mode.setImageResource(R.drawable.random);
                break;
            case AudioPlayService.PLAY_SINGLE_REPEAT:
                play_mode.setImageResource(R.drawable.single_repeat);
                break;
        }
    }

1.3.6根据播放模式自动播放下一首音乐

在服务的 AudioBinder 的 play 方法中给 mediaplay 设置结束的监听，当音乐播放结束之后自动播放下一首

 media_player.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                @Override
                public void onCompletion(MediaPlayer mp) {
                //歌曲播放结束
                //自动播放下一首
                    autoPlayNext();
                }
            });

private void autoPlayNext() {
            switch (playMode){
                case PLAY_ALL_REPEAT:
                    if (position == audioItemList.size()-1) {
                        position = 0;
                    }else {
                        position++;
                    }
                    break;
                case PLAY_RANDOM:
                    position = new Random().nextInt(audioItemList.size());
                    break;
                case PLAY_SINGLE_REPEAT:
                    break;
            }
            play();
        }

至此音乐播放服务和界面已经初步完成了，但是还有一些工作要作补充比如专辑图片和歌词等等，这个我会在之后进行补充，但是一个简略的MP3播放器已经成型，大家也可以根据我的代码自己加工构造出更好的作品，我只是作为抛砖引玉，同时希望也能得到大家的分享。

一线程池的使用

1.线程池的原理

public class ThreadPool {
			int maxCount = 3;
			AtomicInteger count =new AtomicInteger(0);// 当前开的线程数  count=0,atomicInteger可以保持线程同步
			LinkedList<Runnable> runnables = new LinkedList<Runnable>();
		
			public void execute(Runnable runnable) {
				runnables.add(runnable);
				if(count.incrementAndGet()<=3){
					createThread();
				}
			}
			private void createThread() {
				new Thread() {
					@Override
					public void run() {
						super.run();
						while (true) {
							// 取出来一个异步任务
							if (runnables.size() > 0) {
								Runnable remove = runnables.remove(0);
								if (remove != null) {
									remove.run();
								}
							}else{
								//  等待状态   wake();
							}
						}
					}
				}.start();
			}
		}

2.线程池的使用

public class ThreadManager {

	private ThreadManager() {

	}
	private static ThreadManager manager = new ThreadManager();
	private ThreadPoolProxy longPool ;
	private ThreadPoolProxy shortPool ;
	public static ThreadManager getInstance() {
		return manager;
	}
	
	
	/** 操作网络文件的线程*/
	// cpu的核数*2+1
	public synchronized ThreadPoolProxy createLongPool() {
		if (longPool == null) {
			 longPool = new ThreadPoolProxy(5, 5, 5000L);
		}
		return longPool;
	}
	
	/** 操作本地文件的线程*/
	public synchronized ThreadPoolProxy createshortPool() {
		if (shortPool == null) {
			shortPool = new ThreadPoolProxy(3, 3, 5000L);
		}
		return shortPool;
	}

	public class ThreadPoolProxy {
		private ThreadPoolExecutor pool;

		private int corePoolSize;
		private int maximumPoolSize;
		private long time;

		public ThreadPoolProxy(int corePoolSize, int maximumPoolSize, long time) {
			this.corePoolSize = corePoolSize;
			this.maximumPoolSize = maximumPoolSize;
			this.time = time;

		}

		public void execute(Runnable runnable) {
			/*
			 * 1.线程池里面管理的线程数2.如果排队满了额外再开的线程数3.如果线程池没有要执行的任务 存活多久4.时间的单位5.如果
			 * 线程池里管理的线程都已经用了,剩下的任务 临时存到LinkedBlockingQueue对象中 排队10个排队
			 */
			if (pool == null) {
				pool = new ThreadPoolExecutor(corePoolSize, maximumPoolSize,
						time, TimeUnit.MILLISECONDS,
						new LinkedBlockingQueue<Runnable>(10));
			}
			pool.execute(runnable);
		}

		public void cancel(Runnable runnable) {
			// 不为null ，没有停止，，没有崩溃
			if (pool != null && !pool.isShutdown() && !pool.isTerminated()) {
				pool.remove(runnable);
			}
		}
	}
}

二。读取网络数据

1.BaseProtocol

public abstract class BaseProtocol<T> {
	
	private FileWriter writer;
	private BufferedWriter bufferedWriter;
	private BufferedReader bufferedReader;
	private JSONArray jsonArray;
	private T parseJson;
	
	public T load(int index) {
		String json = loadLocal(index);// 1.加载本地数据
		System.out.println("加载了本地数据");

		if (json == null) {// 2.没有本地数据，则加载服务器数据
			json = loadServer(index);
			// System.out.println(json);
			if (json != null) {
				saveLocal(index, json);// 3.保存数据到本地
			}
		}

		if (json != null) {// 4.如果加载到了本地数据，解析
			parseJson = parseJson(json);
			return parseJson;
		} else {
			return null;
		}
	}
	/** 1.加载本地数据 */
	private String loadLocal(int index) {
		File dir = FileUtils.getFilePath("cache");
		File file = new File(dir, getKey() + index);// 缓存在sdcard/google1/cache文件夹中
		if (file != null) {
			try {
				bufferedReader = new BufferedReader(new FileReader(file));
				long time = Long.parseLong(bufferedReader.readLine());
				if (System.currentTimeMillis() - time > 0) {
					return null;
				} else {
					StringWriter stringWriter = new StringWriter();
					String str;
					while ((str = bufferedReader.readLine()) != null) {
						stringWriter.write(str);
					}
					return stringWriter.toString();
				}
			} catch (Exception e) {
				e.printStackTrace();
				return null;
			} finally {
				IOUtils.closeQuietly(bufferedReader);
			}
		}
		return null;
	}
	
	/** 2.加载服务器数据 */
	private String loadServer(int index) {

		// 这里为什么不用在子线程中运行,因为调用的时候就是在子线程中调用的,用httputils的话里面涉及线程中的线程问题
		StringBuffer buffer = null;
		HttpURLConnection connection = null;
		try {
			URL url = new URL("http://127.0.0.1:8090/" + getKey() + "?index="
					+ index + getParams());
			connection = (HttpURLConnection) url.openConnection();
			connection.setRequestMethod("GET");
			connection.setReadTimeout(8000);
			connection.setConnectTimeout(8000);
			connection.connect();
			if (connection.getResponseCode() == 200) {
				InputStream stream = connection.getInputStream();
				BufferedReader reader = new BufferedReader(
						new InputStreamReader(stream));
				buffer = new StringBuffer();
				String line = "";
				while ((line = reader.readLine()) != null) {
					buffer.append(line);
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		} finally {
			if (connection != null) {
				connection.disconnect();
			}
		}
		return buffer.toString();
	}
	
	private void saveLocal(int index, String json) {

		try {
			File dir = FileUtils.getFilePath("cache");
			File file = new File(dir, getKey() + index);// 缓存在sdcard/google1/cache文件夹中
			writer = new FileWriter(file);
			bufferedWriter = new BufferedWriter(writer);
			bufferedWriter.write(System.currentTimeMillis() + "");
			bufferedWriter.newLine();
			bufferedWriter.write(json);
			bufferedWriter.close();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			IOUtils.closeQuietly(writer);
			IOUtils.closeQuietly(bufferedWriter);
		}
	}
	
	public abstract  T parseJson(String json);
	
	public abstract String getKey();
	public abstract String getParams();
}

public class FileUtils {
	public static final String URL = "http://127.0.0.1:8090/";
	private static final String Root = "google1";
	public static final String ICON = "icon";
	String path = "";
	private static StringBuilder stringBuilder;
	/**
	 * 获取图片的缓存的路径
	 * @return
	 */
	public static File getIconDir(){
		return getFilePath(ICON);
		
	}
	/**
	 * 获取缓存路径
	 * @return
	 */
	public static File getCacheDir() {
		return getFilePath("");
	}
	//获取缓存的路径
	public static File getFilePath(String str) {
		if (Environment.getExternalStorageState().equals(
				Environment.MEDIA_MOUNTED)) {
			stringBuilder = new StringBuilder();
			stringBuilder.append(Environment.getExternalStorageDirectory()
					.getAbsolutePath());
			stringBuilder.append(File.separator);
			stringBuilder.append(Root);
			stringBuilder.append(File.separator);
			stringBuilder.append(str);
		}else{
			File filesDir = BaseApplication.getApplication().getFilesDir();
			stringBuilder.append(filesDir.getAbsolutePath());
			stringBuilder.append(File.separator);
			stringBuilder.append(str);
		}
		File file = new File(stringBuilder.toString());

		// 不存在或者不是一个文件夹
		if (!file.exists() || !file.isDirectory()) {
			file.mkdirs();
		}
		return file;
	}

}

public class HomeProtocol extends BaseProtocol<List<Appinfo>>{
	private JSONArray jsonArray;

	public List<Appinfo> parseJson(String json) {
		JSONObject jsonObject;
		List<Appinfo> appinfos = new ArrayList<Appinfo>();
		try {
			jsonObject = new JSONObject(json);
			jsonArray = jsonObject.getJSONArray("list");
			for (int i = 0; i < jsonArray.length(); i++) {
				JSONObject jsonObject2 = jsonArray.getJSONObject(i);
				long id = jsonObject2.getLong("id");
				String name = jsonObject2.getString("name");
				String packageName = jsonObject2.getString("packageName");
				String iconUrl = jsonObject2.getString("iconUrl");
				float stars = Float.parseFloat(jsonObject2.getString("stars"));
				long size = jsonObject2.getLong("size");
				String downloadUrl = jsonObject2.getString("downloadUrl");
				String des = jsonObject2.getString("des");
				Appinfo appinfo = new Appinfo(id, name, packageName, iconUrl,
						stars, size, downloadUrl, des);
				appinfos.add(appinfo);
			}
			return appinfos;
		} catch (JSONException e) {
			e.printStackTrace();
			return null;
		}

	}

	public String getKey() {
		return "home";
	}

	/** 重写这个后缀,有的有,有的没有,需要的重写 */
	public String getParams() {
		return "";
	}

}

4.设置HomeFragment页面

public class HomeFragment extends BaseFragment {

	private List<Appinfo> data;
	private ListView listView;
	private Myadapter myadapter;
	private BitmapUtils bitmapUtils;
	// 开始的时候就加载HomeFragment的页面
	@Override
	public void onActivityCreated(@Nullable Bundle savedInstanceState) {
		super.onActivityCreated(savedInstanceState);
		show();
	}

	/** 创建了成功的界面 */
	protected View createSuccessView() {
		listView = new ListView(BaseApplication.getApplication());
		myadapter = new Myadapter();
		// listView.setAdapter(myadapter);
		return listView;
	}

	class Myadapter extends BaseAdapter {
	

		@Override
		public int getCount() {
			return data.size();
		}

		@Override
		public Object getItem(int position) {
			return data.get(position);
		}

		@Override
		public long getItemId(int position) {
			return position;
		}

		@Override
		public View getView(int position, View convertView, ViewGroup parent) {
			View view = null;
			ViewHolder holder;
			if (convertView == null) {
				holder = new ViewHolder();
				view = View.inflate(BaseApplication.getApplication(),
						R.layout.item_app, null);
				holder.item_icon = (ImageView) view
						.findViewById(R.id.item_icon);
				holder.item_title = (TextView) view
						.findViewById(R.id.item_title);
				holder.item_size = (TextView) view.findViewById(R.id.item_size);
				holder.item_bottom = (TextView) view
						.findViewById(R.id.item_bottom);
				holder.item_rating = (RatingBar) view
						.findViewById(R.id.item_rating);
				view.setTag(holder);
			} else {
				view = convertView;
				holder = (ViewHolder) view.getTag();
			}
			Appinfo appinfo = data.get(position);
			holder.item_title.setText(appinfo.getName());
			String formatFileSize = Formatter.formatFileSize(
					BaseApplication.getApplication(), appinfo.getSize());
			holder.item_size.setText(formatFileSize);
			holder.item_bottom.setText(appinfo.getDes());
			holder.item_rating.setRating(appinfo.getStarts());

			//http://127.0.0.1:8090/image?name=app/com.youyuan.yyhl/icon.jpg
			// 加载图片
			String iconUrl = appinfo.getIconUrl();
			System.out.println(iconUrl+"-------------");
			bitmapUtils = BitmapHelper.getBitmapUtils();//使用单例模式的BitmapUtils,并且可以缓存到sdcard中
			bitmapUtils.display(holder.item_icon,"http://127.0.0.1:8090" + "/image?name=" + iconUrl);
			bitmapUtils.configDefaultLoadingImage(R.drawable.ic_launcher);
			return view;
		}

	}
 
	// 获取数据从服务器
	protected int LoadDataFromServer() {
		HomeProtocol homeProtocol = new HomeProtocol();
		data = homeProtocol.load(0);

		for (Appinfo appinfo : data) {
			// System.out.println(appinfo.toString());
		}
		getActivity().runOnUiThread(new Runnable() {

			@Override
			public void run() {
				listView.setAdapter(myadapter);
			}
		});
		return checkData(data);
	}

	

	static class ViewHolder {
		ImageView item_icon;
		TextView item_title;
		TextView item_size;
		TextView item_bottom;
		RatingBar item_rating;
	}
}

public class BitmapHelper {
		private BitmapHelper() {
		}
	
		private static BitmapUtils bitmapUtils;
	
		/**
		 * BitmapUtils不是单例的 根据需要重载多个获取实例的方法
		 * 
		 * @param appContext
		 *            application context
		 * @return
		 */
		public static BitmapUtils getBitmapUtils() {
			if (bitmapUtils == null) {
				// 第二个参数 缓存图片的路径 // 加载图片 最多消耗多少比例的内存 0.05-0.8f
				bitmapUtils = new BitmapUtils(UiUtils.getContext(), FileUtils
						.getIconDir().getAbsolutePath(), 0.3f);
			}
			return bitmapUtils;
		}
	}

6.设置ListView的细节处理

## BaseListView 


	public class BaseListView extends ListView {
	
		public BaseListView(Context context) {
			super(context);
			init();
		}
	
		public BaseListView(Context context, AttributeSet attrs, int defStyle) {
			super(context, attrs, defStyle);
			init();
		}
	
		public BaseListView(Context context, AttributeSet attrs) {
			super(context, attrs);
			init();
		}
	
		private void init() {
	//		setSelector  点击显示的颜色
	//		setCacheColorHint  拖拽的颜色
	//		setDivider  每个条目的间隔	的分割线	
			this.setSelector(R.drawable.nothing);  // 什么都没有
			this.setCacheColorHint(R.drawable.nothing);
			this.setDivider(UiUtils.getDrawalbe(R.drawable.nothing));
		}
	
	}

主要分析Stable Privacy Address在kernel中的实现code

Kernel Version: 4.6

无状态地址配置过程

一般情况下，在对应的网卡启动的时候，如果支持IPV6，且软件的IPV6功能使能，就会自动配置一个Link local地址，这个link local地址就是以fe80开头，同时有了link local地址之后，系统就会发送一个RS的packet到网络中去，如果路由器支持IPV6，收到这个RS之后，会回复一个携带prefix信息的RA包，Host收到RA包之后，提取prefix，生成interface id，组成一个global地址，这个过程就是无状态地址配置的过程.

RS packet : 

从图中看出，属于ICMPV6协议的封包，使用link local address发送，目的地址是路由器多播组

RA packet:

Host收到RA之后，就提取prefix，组成一个global地址

Kernel 实现分析

在kernel中专门提供了这样一个patch增加了对RFC7217的支持。Patch：ipv6: generation of stable privacy addresses for link-local and autoconf

@@ -2302,6 +2305,11 @@ void addrconf_prefix_rcv(struct net_device *dev, u8 *opt, int len, bool sllao)
 				       in6_dev->token.s6_addr + 8, 8);
 				read_unlock_bh(&in6_dev->lock);
 				tokenized = true;
+			} else if (in6_dev->addr_gen_mode ==
+				   IN6_ADDR_GEN_MODE_STABLE_PRIVACY&&
+				   !ipv6_generate_stable_address(&addr, 0,
+								 in6_dev)) {
+				goto ok;
 			} else if (ipv6_generate_eui64(addr.s6_addr + 8, dev) &&
 				   ipv6_inherit_eui64(addr.s6_addr + 8, in6_dev)) {
 				in6_dev_put(in6_dev);

static int ipv6_generate_stable_address(struct in6_addr *address,
					u8 dad_count,
					const struct inet6_dev *idev)
{
	static DEFINE_SPINLOCK(lock);
	static __u32 digest[SHA_DIGEST_WORDS]; //160bit消息摘要
	static __u32 workspace[SHA_WORKSPACE_WORDS];
	
	static union {
		char __data[SHA_MESSAGE_BYTES]; //512bit data block ： 128bit secret + 64bit prefix + 256bit HW + 8bit DAD_Count;
		struct {
			struct in6_addr secret;
			__be32 prefix[2];
			unsigned char hwaddr[MAX_ADDR_LEN];
			u8 dad_count;
		} __packed;
	} data;

	struct in6_addr secret;
	struct in6_addr temp;
	struct net *net = dev_net(idev->dev); // 取得网卡的device结构体

	BUILD_BUG_ON(sizeof(data.__data) != sizeof(data));

	//获取初始化的scret
	if (idev->cnf.stable_secret.initialized)
		secret = idev->cnf.stable_secret.secret;
	else if (net->ipv6.devconf_dflt->stable_secret.initialized)
		secret = net->ipv6.devconf_dflt->stable_secret.secret;
	else
		return -1; //如果没有scret，直接返回-1
retry:
	spin_lock_bh(&lock);

	sha_init(digest); //初始化SHA-1的原始消息摘要值
	memset(&data, 0, sizeof(data)); //清0，data区域
	memset(workspace, 0, sizeof(workspace));//清0，workspace
	memcpy(data.hwaddr, idev->dev->perm_addr, idev->dev->addr_len); //将设备的mac地址复制到data中
	data.prefix[0] = address->s6_addr32[0]; //prefix信息
	data.prefix[1] = address->s6_addr32[1];
	data.secret = secret; // secret 信息 到data
	data.dad_count = dad_count; //dad_count 传入的值，赋值给data

	sha_transform(digest, data.__data, workspace); //使用SHA-1算法进行加密，并产生160bit的摘要信息

	temp = *address; 
	//这个地方就是使用160bit的摘要信息的前64bit，赋值给IPV6地址的后64bit，这样就组成了一个prefix + interface id的完整地址
	temp.s6_addr32[2] = (__force __be32)digest[0];
	temp.s6_addr32[3] = (__force __be32)digest[1];

	spin_unlock_bh(&lock);

	//判断是否是保留的interface id，这些interface id不能被使用
	if (ipv6_reserved_interfaceid(temp)) {
		dad_count++;// 如果和保留interface id 一致，则dad_count加1
		//如果dad_count > idgen_retries 生成stable address失败，否则retry
		if (dad_count > dev_net(idev->dev)->ipv6.sysctl.idgen_retries)
			return -1;
		goto retry;
	}

	*address = temp;
	return 0;
}

/**
 * sha_init - initialize the vectors for a SHA1 digest
 * @buf: vector to initialize
 */
void sha_init(__u32 *buf)
{
	buf[0] = 0x67452301;
	buf[1] = 0xefcdab89;
	buf[2] = 0x98badcfe;
	buf[3] = 0x10325476;
	buf[4] = 0xc3d2e1f0;
}

sha_transform 

/*
 * Where do we get the source from? The first 16 iterations get it from
 * the input data, the next mix it from the 512-bit array.
 */
#define SHA_SRC(t) get_unaligned_be32((__u32 *)data + t)
#define SHA_MIX(t) rol32(W(t+13) ^ W(t+8) ^ W(t+2) ^ W(t), 1)

#define SHA_ROUND(t, input, fn, constant, A, B, C, D, E) do { \
	__u32 TEMP = input(t); setW(t, TEMP); \
	E += TEMP + rol32(A,5) + (fn) + (constant); \
	B = ror32(B, 2); } while (0)

#define T_0_15(t, A, B, C, D, E)  SHA_ROUND(t, SHA_SRC, (((C^D)&B)^D) , 0x5a827999, A, B, C, D, E )
#define T_16_19(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (((C^D)&B)^D) , 0x5a827999, A, B, C, D, E )
#define T_20_39(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) , 0x6ed9eba1, A, B, C, D, E )
#define T_40_59(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, ((B&C)+(D&(B^C))) , 0x8f1bbcdc, A, B, C, D, E )
#define T_60_79(t, A, B, C, D, E) SHA_ROUND(t, SHA_MIX, (B^C^D) ,  0xca62c1d6, A, B, C, D, E )

void sha_transform(__u32 *digest, const char *data, __u32 *array)
{
	__u32 A, B, C, D, E;

	A = digest[0];
	B = digest[1];
	C = digest[2];
	D = digest[3];
	E = digest[4];

	/* Round 1 - iterations 0-16 take their input from 'data' */
	T_0_15( 0, A, B, C, D, E);
	T_0_15( 1, E, A, B, C, D);
	T_0_15( 2, D, E, A, B, C);
	T_0_15( 3, C, D, E, A, B);
	T_0_15( 4, B, C, D, E, A);
	T_0_15( 5, A, B, C, D, E);
	T_0_15( 6, E, A, B, C, D);
	T_0_15( 7, D, E, A, B, C);
	T_0_15( 8, C, D, E, A, B);
	T_0_15( 9, B, C, D, E, A);
	T_0_15(10, A, B, C, D, E);
	T_0_15(11, E, A, B, C, D);
	T_0_15(12, D, E, A, B, C);
	T_0_15(13, C, D, E, A, B);
	T_0_15(14, B, C, D, E, A);
	T_0_15(15, A, B, C, D, E);

	/* Round 1 - tail. Input from 512-bit mixing array */
	T_16_19(16, E, A, B, C, D);
	T_16_19(17, D, E, A, B, C);
	T_16_19(18, C, D, E, A, B);
	T_16_19(19, B, C, D, E, A);

	/* Round 2 */
	T_20_39(20, A, B, C, D, E);
	T_20_39(21, E, A, B, C, D);
	T_20_39(22, D, E, A, B, C);
	T_20_39(23, C, D, E, A, B);
	T_20_39(24, B, C, D, E, A);
	T_20_39(25, A, B, C, D, E);
	T_20_39(26, E, A, B, C, D);
	T_20_39(27, D, E, A, B, C);
	T_20_39(28, C, D, E, A, B);
	T_20_39(29, B, C, D, E, A);
	T_20_39(30, A, B, C, D, E);
	T_20_39(31, E, A, B, C, D);
	T_20_39(32, D, E, A, B, C);
	T_20_39(33, C, D, E, A, B);
	T_20_39(34, B, C, D, E, A);
	T_20_39(35, A, B, C, D, E);
	T_20_39(36, E, A, B, C, D);
	T_20_39(37, D, E, A, B, C);
	T_20_39(38, C, D, E, A, B);
	T_20_39(39, B, C, D, E, A);

	/* Round 3 */
	T_40_59(40, A, B, C, D, E);
	T_40_59(41, E, A, B, C, D);
	T_40_59(42, D, E, A, B, C);
	T_40_59(43, C, D, E, A, B);
	T_40_59(44, B, C, D, E, A);
	T_40_59(45, A, B, C, D, E);
	T_40_59(46, E, A, B, C, D);
	T_40_59(47, D, E, A, B, C);
	T_40_59(48, C, D, E, A, B);
	T_40_59(49, B, C, D, E, A);
	T_40_59(50, A, B, C, D, E);
	T_40_59(51, E, A, B, C, D);
	T_40_59(52, D, E, A, B, C);
	T_40_59(53, C, D, E, A, B);
	T_40_59(54, B, C, D, E, A);
	T_40_59(55, A, B, C, D, E);
	T_40_59(56, E, A, B, C, D);
	T_40_59(57, D, E, A, B, C);
	T_40_59(58, C, D, E, A, B);
	T_40_59(59, B, C, D, E, A);

	/* Round 4 */
	T_60_79(60, A, B, C, D, E);
	T_60_79(61, E, A, B, C, D);
	T_60_79(62, D, E, A, B, C);
	T_60_79(63, C, D, E, A, B);
	T_60_79(64, B, C, D, E, A);
	T_60_79(65, A, B, C, D, E);
	T_60_79(66, E, A, B, C, D);
	T_60_79(67, D, E, A, B, C);
	T_60_79(68, C, D, E, A, B);
	T_60_79(69, B, C, D, E, A);
	T_60_79(70, A, B, C, D, E);
	T_60_79(71, E, A, B, C, D);
	T_60_79(72, D, E, A, B, C);
	T_60_79(73, C, D, E, A, B);
	T_60_79(74, B, C, D, E, A);
	T_60_79(75, A, B, C, D, E);
	T_60_79(76, E, A, B, C, D);
	T_60_79(77, D, E, A, B, C);
	T_60_79(78, C, D, E, A, B);
	T_60_79(79, B, C, D, E, A);

	digest[0] += A;
	digest[1] += B;
	digest[2] += C;
	digest[3] += D;
	digest[4] += E;
}

static bool ipv6_reserved_interfaceid(struct in6_addr address)
{
	// interface id 为0 ，认为失败
	if ((address.s6_addr32[2] | address.s6_addr32[3]) == 0)
		return true;
	
	if (address.s6_addr32[2] == htonl(0x02005eff) &&
	    ((address.s6_addr32[3] & htonl(0xfe000000)) == htonl(0xfe000000)))
		return true;

	if (address.s6_addr32[2] == htonl(0xfdffffff) &&
	    ((address.s6_addr32[3] & htonl(0xffffff80)) == htonl(0xffffff80)))
		return true;

	return false;
}

void addrconf_dad_failure(struct inet6_ifaddr *ifp)
{
	struct in6_addr addr;
	struct inet6_dev *idev = ifp->idev;
	struct net *net = dev_net(ifp->idev->dev);

	if (addrconf_dad_end(ifp)) {
		in6_ifa_put(ifp);
		return;
	}
	//进入这个函数说明DAD失败
	net_info_ratelimited("%s: IPv6 duplicate address %pI6c detected!\n",
			     ifp->idev->dev->name, &ifp->addr);

	spin_lock_bh(&ifp->lock);

	//如果地址flag有IFA_F_STABLE_PRIVACY，说明是stable address
	if (ifp->flags & IFA_F_STABLE_PRIVACY) {
		int scope = ifp->scope;
		u32 flags = ifp->flags;
		struct in6_addr new_addr;
		struct inet6_ifaddr *ifp2;
		u32 valid_lft, preferred_lft;
		int pfxlen = ifp->prefix_len;
		int retries = ifp->stable_privacy_retry + 1;  //retry 次数加一
		
		//如果重传次数大于idgen_retries，就彻底失败
		if (retries > net->ipv6.sysctl.idgen_retries) {
			net_info_ratelimited("%s: privacy stable address generation failed because of DAD conflicts!\n",
					     ifp->idev->dev->name);
			goto errdad;
		}
		
		//否则重新生成ipv6_generate_stable_address，retries 为DAD_Counter
		new_addr = ifp->addr;
		if (ipv6_generate_stable_address(&new_addr, retries,
						 idev))
			goto errdad;

		valid_lft = ifp->valid_lft;
		preferred_lft = ifp->prefered_lft;

		spin_unlock_bh(&ifp->lock);

		if (idev->cnf.max_addresses &&
		    ipv6_count_addresses(idev) >=
		    idev->cnf.max_addresses)
			goto lock_errdad;

		net_info_ratelimited("%s: generating new stable privacy address because of DAD conflict\n",
				     ifp->idev->dev->name);
		//重新设置到接口中
		ifp2 = ipv6_add_addr(idev, &new_addr, NULL, pfxlen,
				     scope, flags, valid_lft,
				     preferred_lft);
		if (IS_ERR(ifp2))
			goto lock_errdad;

		spin_lock_bh(&ifp2->lock);
		ifp2->stable_privacy_retry = retries;
		ifp2->state = INET6_IFADDR_STATE_PREDAD;
		spin_unlock_bh(&ifp2->lock);

		addrconf_mod_dad_work(ifp2, net->ipv6.sysctl.idgen_delay);
		in6_ifa_put(ifp2);
lock_errdad:
		spin_lock_bh(&ifp->lock);
	} else if (idev->cnf.accept_dad > 1 && !idev->cnf.disable_ipv6) {
		addr.s6_addr32[0] = htonl(0xfe800000);
		addr.s6_addr32[1] = 0;

		if (!ipv6_generate_eui64(addr.s6_addr + 8, idev->dev) &&
		    ipv6_addr_equal(&ifp->addr, &addr)) {
			/* DAD failed for link-local based on MAC address */
			idev->cnf.disable_ipv6 = 1;

			pr_info("%s: IPv6 being disabled!\n",
				ifp->idev->dev->name);
		}
	}

errdad:
	/* transition from _POSTDAD to _ERRDAD */
	ifp->state = INET6_IFADDR_STATE_ERRDAD;
	spin_unlock_bh(&ifp->lock);
	//再次进行dad检查
	addrconf_mod_dad_work(ifp, 0);
}

以前整理在word文档里的,不过最近下重新整理资料,还是把这些东西放到博客里吧,方便查找,在顺带撑撑门面

一storyboard连线问题


产生原因：将与storyboard关联的属性删除了，但是storyboard中还保持之前所关联的属性。
解决：
1.    点击view controller
2.    点击这排最后一个按钮
3.    会出现
4.    发现感叹号。点击感叹号的左边的x，取消关联就不会报错了。

二 文本框中怎么输入显示类似输入密码时候的东东。

解决：勾选这个

三．输入文本的时候，怎么显示右边的X按钮

1.点击

2.会显示

3.选择，表示当编辑的时候，会出出现X。

效果：

11.22 常见问题

一．Storyboard连线问题。

报错原因：1.没有实现btnClick这个方法。

解决方式一：添加这个btnClick这个方法

解决方式二：

1.点击view controller

2.点击这排最后一个按钮

3.会出现

4.发现感叹号没，和之前一样，x了它，就哦了。

注意点；OC中冒号也算做方法名的一部分喔，记住！

二．结构体问题

报错原因：OC语法规定：不允许直接修改某个对象的结构体属性的成员

_btn 是个对象

frame是个结构体。

对象和结构体是不一样的，结构体是C语言中的，里面可以定义许多属性，但是不能定义方法，而对象是即可以定义属性又可以定义方法的，是典型的面向对象语法。

如何改变对象中结构体属性的成员：

解决方法一：

    // 既然不能直接修改对象中的结构体属性成员

    // 先取出结构体

    CGRect frame = _btn.frame;

    // 修改结构体

    frame.origin.y -= 10;

    // 将修改后的结构体重新赋值回去

    _btn.frame = frame;

解决方法二：

    // 先取出y值

    CGFloat y = _btn.frame.origin.y;

    // 修改y值

    y -= 10;

    // 重新设置_btn的y值，其他属性和_btn保持不变

_btn.frame = CGRectMake(_btn.frame.origin.x, y, _btn.frame.size.width,_btn.frame.size.height);

三．Id问题

报错原因：id类型不能使用点语法

解决方式一：

    // 利用get方法获取tag值

    NSInteger i = [sender tag];

解决方式二：

// 将id强转为UIButton

    UIButton *button = (UIButton *)sender;

    // 就能使用点语法获取tag，编译器很笨的，他只会根据当前类型，去判断是否能使用这个语法。一般强转为对应类型，就能使用对应类型的方法了。

NSInteger i = button.tag;

四．如果发现给控件设置transform属性，控件没有任何反应，或者反应了，但是效果不对。

解决方法：将这个选项取消勾选。

五．如果想让同一个控件同时即改变位置的移动，又放大。这样设置是无效果的。

    _btn.transform = CGAffineTransformMakeTranslation(0, 100);

_btn.transform = CGAffineTransformMakeScale(1.2, 1.2);

这样操作是创建新的transform然后赋值，给按钮的transform，第二次赋值的会把之前赋值的给覆盖，所以会达不到想要的效果。

解决方法：

    _btn.transform = CGAffineTransformMakeTranslation(0, 100);

    // 在之前的transform情况下，继续添加缩放的形变。

    _btn.transform = CGAffineTransformScale(_btn.transform, 1.2, 1.2);

六．四舍五入问题。

float i = 1.7;

    // 会自动四舍五入，不保留小数

    NSLog(@"%0.f",i); // 打印结果2

    // 强转类型不会四舍五入

    int j = (int)i;

    NSLog(@"%d",j); // 打印结果1

七．优先级问题

//    int b = 2;

//    int a = 4 *(b == 2? 1:2);

//   NSLog(@"%d",a); 打印出4

//    int a = 4 * b == 2? 1:2;

//    NSLog(@"%d",a); 打印出2

//    由此得出 * 比== 优先级高，先算*,在算==

八．模拟器黑屏

解决方法：

九．打代码时，Xcode没提示

解决方法：

0. 点击Preferences

1. 进入Text Editing

2. 勾选

十．有的同学可能在勾选 Autolayout的时候，搞错了对象，误把控制器的View的User Interaction Enabled勾选掉了。

解决办法：User Interaction Enabled 必须勾选，否则控制器根视图中所有子控件无法进行任何操作。

11.23 常见问题

一．访问权限

错误：

会报链接错误。

报错原因，利用下划线访问了@package这个权限里的东西。

被@package 修饰的成员属性只能在同一个框架内部才允许访问。否则会引发link erro。

@private 实例变量只能被声明它的类访问

@protected 实例变量能被声明它的类和子类访问。

@public 实例变量可以被任何类访问。

11.24 常见问题

一．运行程序时，显示运行完成，但是模拟器没反应。

问题原因：有时候应用程序的标示符一样，会导致程序不能成功运行。

解决方式一：将模拟器之前的程序删除。

解决方式二:  将模拟器还原

二．2d表示保留两位 02d 表示不够了用0来补齐。

    NSLog(@"%02d",cols);

三．Plist文件读取。

错误原因：不要看到有很多元素的，就认为是数组。

这样解析是错误的。

_dict = [NSArray arrayWithContentsOfFile:path];

这个pist文件是一个字典，正确的解析此plist文件。

   // 2.根据文件路径加载字典

_dict = [NSDictionary dictionaryWithContentsOfFile:path];

四，给程序拖图片的时候，一定要注意，如下图勾选的，都要勾选中。

五．禁用UITextField的双击出现复制粘贴剪切等操作

解决方式：

有时候我们需要禁用UITextField的双击出现copy paste的功能，然而UITextField本身没有直接设置禁止用户复制粘贴剪切操作等方法，但是可以重载canPerformAction方法来实现。

新建一个类继承UITextField，然后实现canPerformAction方法：
只需覆盖canPerformAction:withSender方法就可以，canPerformAction:withSender属于UIResponder类的。

如下：

-(BOOL)canPerformAction:(SEL)actionwithSender:(id)sender {

UIMenuController*menuController = [UIMenuController sharedMenuController];

if (menuController){

[UIMenuControllersharedMenuController].menuVisible = NO;

}

returnNO;

}

11.25 常见问题

1.将UIButton添加到UILabel，UIButton是不能点击的。

原因： 1.UILabel是继承UIView的，默认不能监听点击事件。UIButton是继承UIControl能够监听点击事件。

2.将UIButton添加到UILabel，他们之间的关系是UILabel是UIButton的父视图，父视图都不能监听点击事件，自然而然不会将事件传递给子视图，因此UIButton也不能监听点击事件了。

思维指导：有些人会认为UIControl不是继承UIView的吗，都是继承UIView，为什么单独继承UIControl可以监听点击事件，继承UIControl的父类UIView不能监听事件了，这是因为我们一般在父类里实现的都是一些共用的属性和方法，而在子类中具体实现子类特有的方法。因此在UIControl实现了监听点击的特有方法，即继承UIControl才能监听点击事件。

2.发现不少人在给成员变量初始化的时候，容易进错一个方法去初始化。

注意这个方法只有在内存发生警告的时候才会调用。

- (void)didReceiveMemoryWarning

{

    [super didReceiveMemoryWarning];

    // Dispose of any resources that can be recreated.

}

大部分成员属性的初始化应该在viewDidLoad里面进行。

- (void)viewDidLoad

{

    [super viewDidLoad];

}

最牛解决方法：在一开始就将didReceiveMemoryWarning这个方法删掉。删掉不会影响程序运行。

3.模拟器问题

当出现这个问题的时候，原因：没有选择模拟器。

解决办法：

11.26常见问题

1.对象方法和类方法问题(此问题基础好的可以看看，基础稍微差的，可以先放着，以后回顾的时候，看看。)

    // 创建视图的工厂方法

    + (UIView *)rowViewInitWithicon:(UIImage*)icon shuju:(NSString *)shuju

    {

        rowView *viewtext = [[NSBundlemainBundle]loadNibNamed:@"rowView" owner:nil options:nil][0];

        [viewtext.btntouxiangsetBackgroundImage:icon forState:UIControlStateNormal];

        viewtext.mingzilablexiao.text = shuju;

        // 重点是这句

        //  这是往通知中心添加一条通知指定通知名称为  back  当观察者self监听到 back 通知是就调用callback

        [[NSNotificationCenter defaultCenter]addObserver:self selector:@selector(callback) name:@"back" object:nil];

        /*   以下是报错信息：

         +[rowView callback]: unrecognizedselector sent to class 0x79d8

         2013-11-26 15:31:02.581lianxirenlianxi[1266:c07] *** Terminating app due to uncaught exception'NSInvalidArgumentException', reason: '+[rowView callback]: unrecognizedselector sent to class 0x79d8'

         */

        // reason: '+[rowView callback]: 看到报错原因里的+就想到没有实现callback这个类方法。

        // 由于self这个观察者是在类方法中添加的，指的是一个类，所以在调用方法的时候，他会去类方法中找有没有这个方法，不会去对象方法中找。因此我们也应该实现类方法。因此这里的self也只能调用类方法

    //由于实现的callback为对象方法  所以会报错

        //  解决方法  把callback  写成类方法   供观察者调用

        return viewtext;

    }

    //callback方法

    - (void)callback

    {

        NSLog(@"11111111111");

    }

解决方法，将callback 写成类方法供观察者调用

//callback方法

    + (void)callback

    {

        NSLog(@"11111111111");

    }

2.Xib是用来描述视图长什么样子，一个项目中允许有很多xib，因此我们需要给xib绑定一个标识，即他View中对应的class是谁，就代表描述哪个class。

Xib中owner的class是用来告诉xib中的View需要调用哪个对象的方法，就填谁。比如需要调用dog类中的方法，就填dog。

注意：在连线选择上别连错了，

步骤一：先考虑自己是想给视图添加控件了还是想给视图添加事件

步骤二：添加控件就跟xib中的view连线。添加一些事件就给xib中的File’s Owner 连线。

3.代码顺序问题

[UIView animateWithDuration:0.5 animations:^{

        CGRect  tmpFrame = sender.superview.frame;

        tmpFrame.origin.x = self.view.frame.size.width;

       sender.superview.frame = tmpFrame;

       sender.superview.alpha = 0;

    } completion:^(BOOL finished) {

        int index = [self.view.subviewsindexOfObject:sender.superview];

       [sender.superview removeFromSuperview];

        [UIView animateWithDuration:0.2 animations:^{

            for (int i = index; i<self.view.subviews.count; i++)

            {

                UIView *chlid = self.view.subviews[i];

                CGRect tmp = chlid.frame;

               tmp.origin.y -=kViewH+1;

               chlid.frame =tmp;

            }

        }];

        // 在这判断删除按钮是否允许点中，会在动画执行完毕的时候，判断。

        _removeIteam.enabled = self.view.subviews.count>1;

    }];

     // 而在执行代码块之外，判断删除按钮是否允许点中是不对的，因为动画是在后台运行的，所以在执行动画的时候，就已经执行完判断语句了，而这时最后一个视图还没销毁掉，因此删除按钮永远不会不允许选中，也就不能在判断删除按钮是否允许点中。

//_removeIteam.enabled = self.view.subviews.count>1;

删完最后一行之后，正确的效果。

删完最后一行之后，错误的效果。原因，判断的位置放错了。

4.Xib描述视图的时候，已经固定好描述视图的宽高了，外界调用视图的时候，只需要设置x，y值就好了

1.出现的问题，创建xib描述的视图时，将宽度设置为一个按钮的宽度了，导致删除按钮不能点击。

#pragma mark 添加联系人

- (IBAction)AddPerson:(UIBarButtonItem *)sender {

    NSString *imgName=[NSString stringWithFormat:@"01%d.png",arc4random_uniform(9)];

    NSString *labelName = arr[arc4random_uniform(arr.count)];

    RowView *rowView = [RowView rowViewWithIcon:imgName name:labelName];

    UIView *lastView = [self.view.subviews lastObject];

    int nextY = lastView.frame.origin.y + kSpace + kItemHW ;

    // 设置rowView的位置和尺寸

    CGRect cg =CGRectMake(0, nextY, kItemHW, kItemHW);

    rowView.frame=cg;

    [self.view addSubview:rowView];

}

错误原因：设置rowView的宽度为kItemHW，因此会有以上图片的出现。

错误会导致删除按钮不能点击，原因：父视图的尺寸不够，即父视图能接收事件的尺寸只有一点点，也就导致超出父视图尺寸的子视图不能监听点击事件。还有一点需要注意，将子视图添加到父视图尺寸之外的位置，只要还在屏幕上就会显示子视图，只不过它不能接收任何事件。

解决方法：CGRect cg =CGRectMake(0, nextY,rowView.frame.size.width , kItemHW);

  这样设置就好了，因为xib里面已经设置了rowView的尺寸了，外界不需要更改视图的宽度了，直接获取视图的宽度即可。

正确效果：

5.  UIToolBar问题

注意UIToolBar中不能使用viewWithTag这个方法，获取UIToolBar里的子视图。因为UIToolBar里的子视图都是UIBarButtonItem,而UIBarButtonItem是继承NSObject的，因此不能使用viewWithTag获取UIToolBar里的子视图，

viewWithTag：实现原理

- (UIView *)viewWithTag:(NSInteger)tag

{

// 1.如果当前tag和当前视图tag相同，直接返回

if (self.tag == tag) return self;

    // 2.如果和当前视图tag不相同，遍历当前视图的所有子控件，查找对应的tag。

for (UIView *view in self.subviews) {

   // 3.如果view不是UIView类或者UIView的子类直接返回nil

if (![view isKindOfClass:[UIView class]]) return nil;

        if (tag == view.tag) {

    //  4. 返回有相匹配的视图

            return view;

        }

    }

    // 5.如果都没有找到，返回nil.

    return nil;

}

       11.27常见问题

1.结构体和对象问题

// 这样定义是错的，结构体不是对象，声明变量是不需要加*

CGRect *frame = self.view.frame;

结构体变量正确定义：

CGRect frame = self.view.frame;

CGPoint center = self.view.center;

CGSize size = self.view.frame.size;

2.内存管理问题

            错误打印：

正确打印:

当对象被销毁，一定会调用的方法，可以用这个方法，判断对象在什么时候销毁,用这个调试。

3.创建模型的时候，尽量自定义一个工厂方法供外界调用。

// 工厂方法，简化对象的实例化

+ (id)provinceWithName:(NSString *)name;

工厂方法好处：简化对象的实例化，快速创建对象。

4.非ARC内存管理问题。

有些同学在创建项目的时候忘记点ARC了，导致一些成员属性都莫名其妙的释放了。然后出现了一系列莫名其妙的错误。

在滚动UITableView的时候出现野指针错误。

一出现这些野指针错误，首先应该想到某些对象被释放了，然后发现代码中，并没有什么造成对象被释放的情况，这时候应该马上想到很可能是非ARC弄的。下图为怎么查看项目是否是非ARC。

在非ARC中没有强引用的概念，因此下图的成员变量是没有被强引用的。

在看看下图，allPro数组没有通过alloc调用，没有调用alloc产生的对象都是自动释放的

    allPro=@[

            @{

                kCities:@[@"浦东",@"杨浦",@"闸北",@"闵行"],

                kHeader:@"上海",

                kFooter:@"上海不错"

            },

            @{

                kCities:@[@"海淀",@"昌平",@"天安门"],

                kHeader:@"北京",

                kFooter:@"北京很好"

             }

    ];

所以在滚动的时候会出现野指针错误，因此需要将项目改成ARC。如下图

两个勾都得选中，然后一直点确认就OK了。

6.  数据模型属性采用的策略中除了基本类型需要用assign，字符串需要用copy，其他对象类型都需要用strong。而控制器中视图采用的策略需要根据情况而定。

下图就是数据模型中属性用错了策略导致，UITableViewcell重新出现到界面时，会导致数据丢失。

11.29 常见问题

1.想在点击cell时做些操作，方法选错了。

下面两个方法太相似了，很容易选错。

// 当点击一行cell时，会调用这个方法

-  (void)tableView:(UITableView *)tableViewdidSelectRowAtIndexPath:(NSIndexPath *)indexPath

// 当取消选择一行cell时，会调用这个方法

-   (void)tableView:(UITableView *)tableViewdidDeselectRowAtIndexPath:(NSIndexPath *)indexPath

2.字符串小调试技巧

当把一个字符串转换成基本数据类型时，字符串打印有值，但是转换成基本数据类型为0时，这个莫名其妙的问题，首先应该想到字符串中很可能有换行符合等，导致转换不成功。

NSString *str = @"                                                                                 123";

    NSInteger i = [str integerValue];

    NSLog(@"%@",str);

NSLog(@"%d",i);

碰到这种情况，可以在打印字符串的时候在占位符两边各加一个数字.

    NSLog(@"1%@1",str);

然后看打印结果就能知道有字符串中有多少空行了

只要将空行去掉就能转换成功了。

字符串去掉空格的方法

// 此方法是通过什么字符集裁剪字符串。

- (NSString *)stringByTrimmingCharactersInSet:(NSCharacterSet *)set;

NSCharacterSet对象可以通过类方法创建

    // 创建空格和换行字符集

    [NSCharacterSet whitespaceAndNewlineCharacterSet];

    // 创建空格字符集

    [NSCharacterSet whitespaceCharacterSet];

3.下图的警告意思是:初始化时，类型指向不匹配，应该用NSArray * 而不是YZPerson *

找到原因后，然后看person方法是怎么声明。

解决方式：将NSArray * 改成id。

11.30 常见问题

1.UITableView数据源问题

1.1

错误原因：说YZViewController 没有实现tableView:numberOfRowsInSection:

解决方式：实现tableView:numberOfRowsInSection:

1.2

这里返回空，会报错。

UITableView内部实现原理：

数据源实现了这个方法

-(UITableViewCell*)tableView:(UITableView*)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath

tableView内部自动会调用以下方法添加cell。

[tableView addSubview:cell];

如果返回的cell为空，也就意味着生成下面一行代码。

[tableView addSubview:nil];

而addSubview是将右边参数添加到数组中保存起来，而数组是不能添加空值的。所有集合对象都不能出传空。例如数组，字典，NSSet。

以上错误总结：作为tableView的数据源必须实现两个方法。

返回行数

-(NSInteger)tableView:(UITableView*)tableViewnumberOfRowsInSection:(NSInteger)section;

返回每一行显示的内容

-(UITableViewCell*)tableView:(UITableView*)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath

另外返回每一行显示的内容不能返回nil。

2.在数组删除一个模型，并不代表把这个模型给释放了。

上面步骤二，仅仅是将模型从数组中销毁，而模型并没有被销。

12.1 常见问题

1.stroyboard中显示的跟根视图是UIView，而stroyboard的控制器是UITableViewController就会报这个错误

原因是：UITableViewController控制器不能加载UITableView，因为它会去加载stroyboard中的UIView。

解决方式：将stroyboard中的UIView改成UITableView

12.2 常见问题

1.自定义视图的属性命名冲突问题

当发现自己描述的xib和运行的时候展现出来的不一样的时候，这时候已经想到自己命名的属性名称和系统命名的冲突了。

错误原因

系统自带的UITableViewCell中也有imageView这个属性，因此冲突了。

解决办法：将自定义视图的imageView属性名称改成iconView.

注意：以后自定义属性命名不要和系统自带的属性名称相同。

2.链接错误

以后看到duplicate这个词语，错误原因就是重复定义了类,函数方法等等。

一般都是因为导入了.m文件

错误：

解决方式：将#import "newsCell.m"这一行删掉。

3.注意将之前storyboard中控制器删除之后，拖入一个新的控制器的时候，stroyboard中控制器的class也要重新填入自己想要展示的控制器，告诉stroyboard去加载哪个控制器。

12.3常见错误

1.初始化方法命名规范问题。

看见这个错误，应该要想到初始化方法命名错误的问题。因为self只能在init开头的方法中赋值，init必须是一个独立的单词，因此init后的第一个字母必须大写。

12.4常见错误

1.重写set方法忘记赋值，以后重写set方法，第一步就先赋值。

2.strong和weak乱用

一般情况：代理和控件使用weak

其他对象使用strong

基本数据类型使用assign

12.5常见错误

1.QQ好友列表中，展开了列表，但是箭头没动画。

原因：由于代理方法中重新刷新了表格，也就意味着把之前的头部视图给替换了，因此没有动画了，不要创建新的头部，才能让旧的头部执行动画

解决方法：用一个数组或者字典保存所有的头部视图，重新刷新的时候，直接取就OK了。

12.6 常见错误

1.加载xib时，名字是分大小写的，注意名字一定要保持一致。

报错原因：xib是大写的KeyboardTool，而加载的时候名字写成小写了。

解决方式：将加载的xib的名称改成大写。

package com.susu;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo2 {
	public static void main(String[] args) {
		try {
			//创建一个url实例
			URL url=new URL("http://www.baidu.com");
			//通过url的openStream获取url对象所表示资源的字节输入流
			InputStream is=url.openStream();
			//将字节输入流转换为字符输入流
			InputStreamReader isr=new InputStreamReader(is,"utf-8");
			//为字符输入流添加缓冲
			BufferedReader br=new BufferedReader(isr);
			String res=null;
			String line=null;
			//读取数据
			while((line=br.readLine())!=null){
				res+=line;
			}
			br.close();
			isr.close();
			is.close();
			System.out.println(res);
		} catch (MalformedURLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
	}
}

　　这篇博客我们来介绍访问者模式（Visitor Pattern），这也是行为型设计模式之一。访问者模式是一种将数据操作与数据结构分离的设计模式，它可以算是 23 中设计模式中最复杂的一个，但它的使用频率并不是很高，大多数情况下，你并不需要使用访问者模式，但是当你一旦需要使用它时，那你就是需要使用它了。
　　访问者模式的基本想法是，软件系统中拥有一个由许多对象构成的、比较稳定的对象结构，这些对象的类都拥有一个 accept 方法用来接受访问者对象的访问。访问者是一个接口，它拥有一个 visit 方法，这个方法对访问到的对象结构中不同类型的元素做出不同的处理。在对象结构的一次访问过程中，我们遍历整个对象结构，对每一个元素都实施 accept 方法，在每一个元素的 accept 方法中会调用访问者的 visit 方法，从而使访问者得以处理对象结构的每一个元素，我们可以针对对象结构设计不同的访问者类来完成不同的操作，达到区别对待的效果。
　　转载请注明出处：http://blog.csdn.net/self_study/article/details/52778713。
　　PS：对技术感兴趣的同鞋加群544645972一起交流。

设计模式总目录

　　java/android 设计模式学习笔记目录

特点

　　封装一些作用于某种数据结构中的个元素的操作，它可以在不改变这个数据结构的前提下定义作用于这些元素的新的操作。
　　访问者模式使用的场景

• 对象结构比较稳定，但经常需要在此对象结构上定义新的操作；
• 需要对一个对象结构中的对象进行很多不同的并且不相关的操作，而需要避免这些操作“污染”这些对象的类，也不希望在增加新操作时修改这些类。

UML类图

　　
　　访问者模式角色介绍：

• Visitor：接口或者抽象类，它定义了对每一个元素（Element）访问的行为，它的参数就是可以访问的元素，它的方法个数理论上来讲与元素个数是一样的，因此访问者模式要求元素的类族要稳定，如果经常添加、移除元素类，必然会导致频繁地修改 Visitor 接口，如果出现这种情况，则说明不适合使用访问者模式；
• ConcreteVisitor：具体地访问者，它需要给出对每一个元素类访问时所产生的具体行为；
• Element：元素接口或者抽象类，它定义了一个接受访问者（accept）的方法，其意义是指每一个元素都要可以被访问者访问；
• ElementA，ElementB：具体的元素类，它提供接受访问方法的具体实现，而这个具体的实现，通常情况下是使用访问者提供的访问该元素类的方法；
• ObjectStructure：定义当中所提到的对象结构，对象结构是一个抽象表述，它内部管理了元素集合，并且可以迭代这些元素供访问者访问。

示例与源码

　　查阅相关资料时，了解到了有一个分派的概念，总结一下：

分派的概念

　　变量被声明时的类型叫做变量的静态类型(Static Type)，有些人又把静态类型叫做明显类型(Apparent Type)；而变量所引用的对象的真实类型又叫做变量的实际类型(Actual Type)。比如：

List list = null;
list = new ArrayList();

声明了一个变量list，它的静态类型（也叫明显类型）是List，而它的实际类型是ArrayList。根据对象的类型而对方法进行的选择，就是分派(Dispatch)，分派(Dispatch)又分为两种，即静态分派和动态分派。静态分派(Static Dispatch)发生在编译时期，分派根据静态类型信息发生。静态分派对于我们来说并不陌生，方法重载就是静态分派；动态分派(Dynamic Dispatch)发生在运行时期，动态分派动态地置换掉某个方法。接着我们来具体看看静态分派和动态分派：

静态分派

　　Java通过方法重载支持静态分派，我们以一个例子来看一下：

public class StaticDispatch {

    public void sayHello(Human guy) {
        System.out.println("hello, guy!");
    }

    public void sayHello(Man guy) {
        System.out.println("hello, man!");
    }

    public void sayHello(Women guy) {
        System.out.println("hello, women!");
    }

    public static void main(String[] args) {

        Human man = new Man();

        Human women = new Women();

        StaticDispatch sd = new StaticDispatch();

        sd.sayHello(man);

        sd.sayHello(women);

    }
}

class Human {
}

class Man extends Human {
}

class Women extends Human {
}

最后的输出结果：

hello, guy!
hello, guy!

没错，程序就是大家熟悉的重载（Overload），而且大家也应该能知道输出结果，但是为什么输出结果会是这个呢，先来看一下代码的定义：

Human man = new Man();

我们把 Human 称为变量的 静态类型， Man 称为变量的 实际类型，其中，变量的静态类型和动态类型在程序中都可以发生变化，而区别是变量的静态类型是在编译阶段就可知的，但是动态类型要在运行期才可以确定，编译器在编译的时候并不知道变量的实际类型是什么。现在回到代码中，由于方法的接受者已经确定是 StaticDispatch 的实例 sd 了，所以最终调用的是哪个重载版本也就取决于传入参数的类型了。实际上，虚拟机（应该说是编译器）在重载时时通过参数的静态类型来当判定依据的，而且静态类型在编译期就可知，所以编译器在编译阶段就可根据静态类型来判定究竟使用哪个重载版本。于是对于例子中的两个方法的调用都是以 Human 为参数的版本，Java中，所有以静态类型来定位方法执行版本的分派动作，都称为静态分派。

动态分派

　　我们再来看看动态分派，Java 通过方法的重写支持动态分派，它和多态的另外一个重要体现有很大的关联，这个体现是什么，可能大家也能猜出，没错，就是重写（override），我们来看看例子：

public class DynamicDispatch {

    public static void main(String[] args) {
        Human man = new Man();
        Human women = new Women();

        man.sayHello();
        women.sayHello();

        man = new Women();
        man.sayHello();
    }

}

abstract class Human {
    protected abstract void sayHello();
}

class Man extends Human {
    @Override
    protected void sayHello() {
        System.out.println("hello man!");
    }
}

class Women extends Human {
    @Override
    protected void sayHello() {
        System.out.println("hello women!");
    }

}

输出结果很显然：

hello man!
hello women!
hello women!

其实由两次改变 man 变量的实际类型导致调用函数版本不同，我们就可以知道，虚拟机是根据变量的实际类型来调用重写方法的。我们也可以从例子中看出，变量的实际类型是在运行期确定的，重写方法的调用也是根据实际类型来调用的，而不是根据静态类型。我们把这种在运行期根据实际类型来确定方法执行版本的分派动作，称为动态分派。

分派的类型

　　一个方法所属的对象叫做方法的接收者，方法的接收者与方法的参数统称做方法的宗量。比如下面例子中的Test类：

public class Test {
    public void print(String str){
        System.out.println(str);
    }
}

在上面的类中，print() 方法属于 Test 对象，所以它的接收者也就是 Test 对象了。print()方法有一个参数是 str，它的类型是 String。
　　根据分派可以基于多少种宗量，可以将面向对象的语言划分为单分派语言（Uni-Dispatch）和多分派语言（Multi-Dispatch）。单分派语言根据一个宗量的类型进行对方法的选择，多分派语言根据多于一个的宗量的类型对方法进行选择。C++ 和 Java均是单分派语言，多分派语言的例子包括 CLOS 和 Cecil 。按照这样的区分，Java 就是动态的单分派语言，因为这种语言的动态分派仅仅会考虑到方法的接收者的类型，同时又是静态的多分派语言，因为这种语言对重载方法的分派会考虑到方法的接收者的类型以及方法的所有参数的类型。
　　在一个支持动态单分派的语言里面，有两个条件决定了一个请求会调用哪一个操作：一是请求的名字，二是接收者的真实类型。单分派限制了方法的选择过程，使得只有一个宗量可以被考虑到，这个宗量通常就是方法的接收者。在 Java 语言里面，如果一个操作是作用于某个类型不明的对象上面，那么对这个对象的真实类型测试仅会发生一次，这就是动态的单分派的特征。

双重分派

　　一个方法根据两个宗量的类型来决定执行不同的代码，这就是“双重分派”。Java 语言不支持动态的多分派，也就意味着 Java 不支持动态的双分派。但是通过使用访问者模式，也可以在 Java 语言里实现动态的双重分派。在 Java 中可以通过两次方法调用来达到两次分派的目的。类图如下所示：

在图中有两个对象，左边的叫做 West ，右边的叫做 East 。现在 West 对象首先调用 East 对象的 goEast() 方法，并将它自己传入。在 East 对象被调用时，立即根据传入的参数知道了调用者是谁，于是反过来调用“调用者”对象的 goWest() 方法。通过两次调用将程序控制权轮番交给两个对象，其时序图如下所示：

这样就出现了两次方法调用，程序控制权被两个对象像传球一样，首先由 West 对象传给了 East 对象，然后又被返传给了 West 对象。但是仅仅返传了一下球，并不能解决双重分派的问题。关键是怎样利用这两次调用，以及 Java 语言的动态单分派功能，使得在这种传球的过程中，能够触发两次单分派。
　　动态单分派在 Java 语言中是在子类重写父类的方法时发生的。换言之，West 和 East 都必须分别置身于自己的类型等级结构中，就正如上面的访问者模式 uml 类图，我们写出访问者模式的通用代码：
Visitor角色：West.class

public abstract class West {

    public abstract void goWest1(SubEast1 east);
    public abstract void goWest2(SubEast2 east);
}

ConcreteVisitor角色：SubWest1.class 和 SubWest2.class

public class SubWest1 extends West{
    @Override
    public void goWest1(SubEast1 east) {
        System.out.println("SubWest1 + " + east.myName1());
    }

    @Override
    public void goWest2(SubEast2 east) {
        System.out.println("SubWest1 + " + east.myName2());
    }
}

public class SubWest2 extends West{
    @Override
    public void goWest1(SubEast1 east) {
        System.out.println("SubWest2 + " + east.myName1());
    }

    @Override
    public void goWest2(SubEast2 east) {
        System.out.println("SubWest2 + " + east.myName2());
    }
}

Element角色：East.class

public abstract class East {
    public abstract void goEast(West west);
}

ConcreteElement角色：SubEast1.class 和 SubEast2.class

public class SubEast1 extends East{
    @Override
    public void goEast(West west) {
        west.goWest1(this);
    }

    public String myName1(){
        return "SubEast1";
    }
}

public class SubEast2 extends East{
    @Override
    public void goEast(West west) {
        west.goWest2(this);
    }

    public String myName2(){
        return "SubEast2";
    }
}

Client.class

public class Client {
    public static void main(String[] args) {
        //组合1
        East east = new SubEast1();
        West west = new SubWest1();
        east.goEast(west);
        //组合2
        east = new SubEast1();
        west = new SubWest2();
        east.goEast(west);
    }
}

最后结果如下：

SubWest1 + SubEast1
SubWest2 + SubEast1

系统运行时，会首先创建 SubWest1 和 SubEast1 对象，然后客户端调用 SubEast1 的goEast() 方法，并将 SubWest1 对象传入。由于 SubEast1 对象重写了其超类 East 的 goEast() 方法，因此，这个时候就发生了一次动态的单分派。当 SubEast1 对象接到调用时，会从参数中得到 SubWest1 对象，所以它就立即调用这个对象的 goWest1() 方法，并将自己传入。由于 SubEast1 对象有权选择调用哪一个对象，因此，在此时又进行一次动态的方法分派。这个时候 SubWest1 对象就得到了 SubEast1 对象。通过调用这个对象 myName1() 方法，就可以打印出自己的名字和 SubEast 对象的名字，其时序图如下所示：

由于这两个名字一个来自East等级结构，另一个来自West等级结构中，因此，它们的组合式是动态决定的，这就是在 Java 中动态双重分派的实现机制。

总结

　　在现实情况下，我们要根据具体的情况来评估是否适合使用访问者模式，例如，我们的对象结构是否足够稳定，使用访问者模式是否能够优化我们的代码，而不是使我们的代码变得更复杂。在使用一个模式之前，我们应该明确它的使用场景、它能解决什么问题等，以此来避免滥用设计模式的现象，所以，在学习设计模式时，一定要理解模式的适用性以及优缺点。
　　访问者模式的优点：

• 各角色职责分离，符合单一职责原则；
• 能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能，具有良好的扩展性；
• 使得数据结构和作用于结构上的操作解耦，使得操作集合可以独立变化；
• 灵活性。

• 具体元素对访问者公布细节，违反了迪米特原则；
• 具体元素变更时导致修改成本大；
• 违反了依赖倒置原则，为了达到“区别对待”而依赖了具体类，没有依赖抽象。

源码下载

　　https://github.com/zhaozepeng/Design-Patterns/tree/master/VisitorPattern

引用

https://en.wikipedia.org/wiki/Visitor_pattern
http://www.cnblogs.com/java-my-life/archive/2012/06/14/2545381.html
http://blog.csdn.net/jason0539/article/details/45146271
https://my.oschina.net/sel/blog/215959

一、前言

前段时间听朋友说在学习NDK开发，说现在的普通安卓程序猿马上都要失业了，吓得我赶紧去各大招聘平台搜了下，确实有不少招聘都写着要求NDK开发经验、JNI开发经验、H5/JS开发经验、cocos2d开发经验、蓝牙等底层开发经验巴拉巴拉的，还有些招安卓的还要求同时具有ios开发经验是什么鬼... 唉，安卓程序猿不好混呀，近段时间微信小程序也是火的不要不要的，天天处在要失业的阴影中。为了赚口猿粮不容易，还是花点时间来瞅瞅NDK开发（也叫JNI开发）吧。

● NDK

Native Development Kit（NDK）是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C/C++的动态库，并能自动将so和java应用一起打包成apk。

● JNI

Java Native Interface（JNI）标准是java平台的一部分，JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用C/C++代码，C/C++的代码也可以调用java代码。

● JNI与NDK的关系

NDK可以为我们生成了C/C++的动态链接库，JNI是java和C/C++沟通的接口，两者与android没有半毛钱关系，只因为安卓是java程序语言开发，然后通过JNI又能与C/C++沟通，所以我们可以使用NDK+JNI来实现“Java+C”的开发方式。

● 为什么要NDK开发

1、项目需要调用底层的一些C/C++的一些东西（java无法直接访问到操作系统底层（如系统硬件等）），或者已经在C/C++环境下实现了功能代码，直接使用即可。NDK开发常用于驱动开发、无线热点共享、数学运算、实时渲染的游戏、音视频处理、文件压缩、人脸识别等。

2、为了效率更加高效些。这个可能并不能成为NDK开发的优点，因为虽然C/C++代码是高效的，但是在java与C/C++相互调用时增大了开销；

3、基于安全性的考虑。防止代码被反编译，为了安全起见，使用C/C++语言来编写重要的部分以增大系统的安全性，最后生成so库（用过第三方库的应该都不陌生）便于给人提供方便。（任何有效的代码混淆对于会smail语法反编译你apk是分分钟的事，即使你加壳也不能幸免高手的攻击）

4、便于移植。用C/C++写得库可以方便在其他的嵌入式平台上再次使用。

二、安装与配置

首先我们在Android Studio下新建一个安卓项目。然后打开Project Structure界面，如下：

在SDK Location目录下，有SDK和NDK的路径，而这里我们暂时还未下载配置过NDK，故我们需要点击Download Android NDK来进行下载。这里Android Studio会下载最新版本的NDK进行安装，默认会下载保存在SDK的路径。我们在上图中还能看到有一段介绍文字，说SDK以及NDK的路径配置会保存在local.properties文件内，安装完成后我们刷新Project，进local.properties文件查看也能看到SDK与NDK的路径。

NDK下载配置完成之后，需要在gradle.properties文件中加上一行：

android.useDeprecatedNdk=true

javah -jni命令，是根据java文件生成.h头文件的，会自动根据java文件中的类名与方法名生成对应的C/C++里面的方法名。下面是参数配置及其含义：

1.Program:    $JDKPath$\bin\javah.exe    这里配置的是javah.exe的路径
2.Parametes:    -classpath . -jni -d $ModuleFileDir$/src/main/jni $FileClass$    这里$FileClass$指的是要执行操作的类名（包名.类名），$ModuleFileDir$/src/main/jni表示生成的文件保存在这个module目录的src/main/jni目录下。
3.Working: $ModuleFileDir$\src\main\java 

使用方式：选中java文件--->右键--->External Tools--->javah-jni，将生成jni文件夹以及文件夹下的 包名.类名的.h头文件 （名字过长，我们可以自己重命名）。

ndk -build命令，是根据C/C++文件生成so文件的。下面是参数配置及其含义：

1.Program:    F:\apk\sdk\ndk-bundle\ndk-build.cmd    这里配置的是ndk下的ndk-build.cmd的路径（根据实际情况填写）
2.Working: $ModuleFileDir$\src\main\ 

使用方式：选中C/C++文件--->右键--->ExternalTools--->ndk-build，将在main文件夹下生成libs文件夹以及多个so文件，我们可以移动至jniLibs目录下去。

三、简单实例

接下来我们创建一个访问本地C/C++方法的java类。

public class JniTest {
    /**
     * 将用C++代码实现，在android代码中调用的方法：获取当前app的包名
     * @param o
     * @return
     */
    public static native String getPackname(Object o);

    /**
     * 加载so库或jni库
     */
    static {
        System.loadLibrary("JNI_ANDROID_TEST");
    }
}

注意JNI_ANDROID_TEST这个Library名字，之后还会需要用到，要保持一致。该类提供了一个static的native方法，该方法将用来获取app的包名。然后对该文件执行javah -jni操作，生成对应的.h头文件。

如图，已经根据我们的java类生成了对应的.h文件，文件名为包名_类名.h，我们可以手动改名为jnitest.h，里面只有一个方法，返回值为String（jstring），方法名为Java_类的包名_类名_方法名（包名中的分级不是用.而是_），前面两个参数是C++里面必须有的（JNIEnv代表指向JVM的指针，jclass是调用该方法的java对象），第三个就是我们java类的方法里面的参数Object。

然后我们新建一个C++文件，取名为jnitest.cpp，写上需要include的文件，从.h文件中复制方法过来（方法名、参数类型、返回值等必须一致）。

至此，.h文件和c++文件均已完成，接下来还需要在这个jni目录下增加两个文件，Android.mk和Application.mk。

Android.mk，注意LOCAL_MODULE的值与之前的名字相对应，LOCAL_SRC_FILES的值写c++文件。

LOCAL_PATH := $(call my-dir)

include $(CLEAR_VARS)

LOCAL_MODULE := JNI_ANDROID_TEST
LOCAL_SRC_FILES =: jnitest.cpp
include $(BUILD_SHARED_LIBRARY)

Application.mk，注意APP_MODULES的值与之前的名字相对应。

APP_MODULES := JNI_ANDROID_TEST
APP_ABI := all

如图，在main/libs目录下生成了多个so文件，名字为lib+我们指定的库名（同时还生成了obj文件夹，不知是什么东西）。

这时候我们可以在main目录下新建jniLibs文件夹，把生成的libs文件夹内的东西均复制过去，删除新生成的jni、libs、obj三个文件夹。然后在Activity中测试调用，在TextView上显示我们通过C++代码实现的方法getPackname获取app的包名了。

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TextView tv = (TextView) findViewById(R.id.tv_app_package_name);
        tv.setText("packageName: " + JniTest.getPackname(MainActivity.this));
    }
}

测试能正确得到包名，说明调用成功了。我们可以把JniTest类以及so文件给别人去使用，这样别人是看不到我们的代码实现的，能很好的保护我们的源码。

以上内容大部分来自网络，整理并测试过后，给出自己的一个理解以及详细图文操作步骤，本文仅供新手参考。本人也刚开始接触，文中可能存在错误之处，请谨慎。

看了一个点阵的实现形式,感觉挺好的.对其中的技术点总结一下.

点阵的显示原理

当字符或者图片在点阵上需要显示时,可以认为是数据源在对应的像素点上的像素是有或者没有.
如果有那么这一个像素点九显示反之就不显示.
那么需求就来了 如何得到资源数据(字符或者图片)像素值(这个像素值应该是个二位数组).

像素值的存放

在java中所有的数据底层都是byte(字节),字节数据可以存放到byte数组中.那么存放的问题就解决了

字符资源的存放

String.getBytes()
String.getBytes(Charset)
对于字符串数据可以通过上面的两个方法获取字节数组,但是不建议使用第一个,因为第一个会得到一个缺省编码的字节数组.
通过设置特定的编码格式,可以得到大小不同的字节

关于字符资源的转换还有一些其他的点,也顺便记录一下.
与getBytes对应的可以通过设置编码格式从字节数组创建一个新的字符串new String(byte[], Charset) 这里就要求以什么格式获得的字节数组在返回字符串的时候必须设置同样的编码格式,否则就会得到乱码的结果如图所示

另外对于iso8859-1编码的结果在返回的时候也会出现乱码,这个是因为在ISO8859-1编码的编码表中就不存在汉字字符

因此在通过String.getBytes(Charset)和new String(byte[],Charset)进行转换时需要注意当前的编码格式的编码表中存在目标String的码值

对于特殊需求一定需要使用ISO8859-1编码格式的中文字符怎么办呢比如(http header 要求其内容必须时iso8859-1编码)这个时候可以采用借鸡生蛋的转换方法

public static void main(String[] args) {
        String str="我";
        try {
            byte[]str_gbk=str.getBytes("gbk");
            byte[]str_utf8=str.getBytes("utf-8");
            byte[]str_iso88591=str.getBytes("iso8859-1");

            String reslut=new String(str_iso88591, "iso8859-1");
            System.out.println(reslut);
            System.out.println("----------------");

            String resource=new String(str.getBytes("utf-8"), "iso8859-1");
            String result1=new String(resource.getBytes("iso8859-1"), "utf-8");

            System.out.println(result1);
        } catch (UnsupportedEncodingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

GB2312和GBK的关系

1.GBK 是GB2312的扩展
2.GB2312是中国规定的汉字的编码 即简体中文的编码.而GBK
  在兼容GB2312的基础上还支持繁体字的显示,同样还有日文
  的假名

HZK16字库

1.HZK16字库是符合GB2312标准的16*16的点阵字库
2.HZK16的GB2312-80支持的汉字有6763个 
  符号682个其中一级汉字3755个 二级汉字3008个

到这里已经得到了字符的资源了,这里先选择使用gbk编码格式原因下面在解释.

两个字节大小的字节数组里存的是什么

1.第一个字节放的就是该汉字的区号,第二个字节放的就是该汉字的位号
2.GB2312汉字有两个字节编码,范围是0XA1A1~0XFEFE
  其中A1-A9为符号区   B0-F7为汉字区

3.以汉字  我 为例在HZK16字库中找到它对应的32个字节的子模数据.
第一个字节为区号,后一个字节为位号.
其中每个区号记录94个汉字,位号为该汉字在该区中的位置,所以要找到这个汉字就必须找到它的区码和位码.

4.区码   汉字的第一个字节(因为汉字编码是从0XA0区开始的,所以文件最前面就是从0XA0区开始, 要算出相对区码)
位码    汉字的第二个字节

这样就可以得到汉字在HZK16中的绝对位置
offset=(94*(区码－1)＋(位码－1))＊32
注解
1.区码减1是因为数组是以0为开始而区号是以1为开始的
2.(94*(区号－1)＋(位码－1))是一个汉字字模占用的字节数
3.最后乘以32 是因为汉字字库文应从 该位置起的32字节信息记录该字的字模信息

图片资源的存放

相比字符资源的存取,图片就显得轻松多了.
主要就一个方法的使用
public void getPixels (int[] pixels, int offset, int stride, int x, int y, int width, int height)

把位图的数据拷贝到pixels[]中,每一个都由一个表示颜色值的int值来表示
幅度参数表名调用者允许的像素组行间距
参数解释

• pixels 接收位图颜色值的数组
• offset 写入到pixels[]中的第一个像素索引值
• stride pixels[]中的行间距个数值
• x 从位图中读取的第一个像素的x坐标值
• y 从位图中读取的第一个像素的y坐标值
• width 从每一行中读取的像素宽度
• height 读取的行数

int[] pixels = new int[bit.getWidth()*bit.getHeight()];//保存所有的像素的数组，图片宽×高

         bit.getPixels(pixels,0,bit.getWidth(),0,0,bit.getWidth(),bit.getHeight());
         for(int i = 0; i < pixels.length; i++){
             int clr = pixels[i];
                int  red   = (clr & 0x00ff0000) >> 16;  //取高两位
                int  green = (clr & 0x0000ff00) >> 8; //取中两位
                int  blue  =  clr & 0x000000ff; //取低两位
                System.out.println("r="+red+",g="+green+",b="+blue);
         }

整理如下图

前言

这篇文章我将从Retrofit的基本用法出发，透过其使用步骤，一步步的探究Retrofit的实现原理及其源码的设计模式。这篇文章可能会将Retrofit中用到的设计模式和其实现原理穿插着写，所以各位同学也可以选择性的阅读。而对于Retrofit具体使用还不太清楚的同学可以去看的另一篇文章Retrofit2的使用介绍

Retrofit基本用法

我以用户登录作为示例：

声明接口

首先我们先定义一个登录服务接口LoginService，如下：

public interface LoginService {
    @FormUrlEncoded
    @POST("login")
    Call<String> login(@Field("username") String name, @Field("password") String password);
}

创建Retrofit对象

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("http://ittiger.cn")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

发起请求

LoginService service = retrofit.create(LoginService.class);
Call<User> call = service.login("user", "pwd");
call.execute()或call.enqueue()

Retrofit关键类

在讲Retrofit实现原理之前，我先说下Retrofit里面涉及到几个关键类都是干什么用的

1. Retorift： 负责配置请求过程中的基本参数，如：请求地址，结果转换器，自定义OKHttpClient等，同时还会生成请求接口对象
2. Call： 网络请求执行者(Retrofit.Call)，比如：上面示例中最后调用login方法得到的Call对象就是此接口的实例
3. OkHttpCall： 此类是Retrofit.Call接口的实现，示例中最后调用login方法得到的Call对象就是此类的实例。但是其底层网络请求执行都是通过OkHttp.Call接口间接执行的，也就是说OkHttpCall是对OkHttp.Call网络请求功能的封装。
4. Converter & Converter.Factory： 分别负责网络请求结果转换以及生成Converter转换器
5. CallAdapter & CallAdapter.Factory： 分别负责对Retrofit.Call实例(OkHttpCall)进行适配及生成CallAdapter适配器
6. Platform： 确定Retrofit当前运行平台，以及确定当前平台默认的的CallAdapter.Factory和Executor
7. ExecutorCallAdapterFactory： Android平台下的默认CallAdapter.Factory实现
8. ServiceMethod： 解析接口服务所有注解、生成请求对象Request、解析请求结果Response
9. ParameterHandler： 服务接口方法(login())参数解析处理器，配合ServiceMethod进行服务接口参数注解解析
10. RequestBuilder： 根据参数和URL构造请求需要的OkHttp.Request对象

以上就是Retrofit源码实现中比较关键的10个类及其相关作用

使用流程 >> 实现 >> 设计模式

Builder模式创建Retrofit

Retrofit场景

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("http://ittiger.cn")
    .addConverterFactory(GsonConverterFactory.create())
    .build();

上面代码的对象创建方式看着是不是似曾相识，看着很眼熟，没错，Android里面的Dialog的创建就是使用的这种方式：Builder模式

Builder模式定义

将一个复杂对象的构建与它的表示分离，使得同样的构建可以创建不同的表示

Builder模式使用场景

1. 相同的方法不同的执行顺序产生不同的结果
2. 多个部件都可以装配到一个对象中，但是产生的结果不同

Builder模式类图

Retrofit中的Builder模式

1. Retrofit中的Builder模式是简化版的Builder模式，省略了抽象建造者和指挥者
2. 不同的配置会对Retrofit产生不同的影响，如果通过addCallAdapterFactory()配置CallAdapterFactory和不配置CallAdapterFactory会对Retrofit产生完全不同的影响。
3. 如果Retrofit中使用构造方法的方式创建对象，则需要实现多个不同参数的构造方法，而使用构造方法创建对象时如果参数太多，很多时候参数代表的意思是不太理解的，总归来说就是创建过程不直观。

Builder模式优缺点

• 优点：
  
  1. 不需要知道产品内部的组成细节，产品与创建过程解耦
  2. 分步组装产品，使得产品的创建过程更精细更清晰
  3. 容易扩展，新产品只需要新建一个建造者即可
• 缺点：
  
  1. Builder模式创建的产品差异性小，使用范围受限制
  2. 不同的产品会产生多个建造者和指挥者

Retrofit创建流程 >> Platform

在创建Retrofit过程中有这样一行代码：

Retrofit retrofit = new Retrofit.Builder()
...
.build();

从代码可以看到在创建Retrofit时得先根据Retrofit.Builder内部类的默认构造方法Retrofit.Builder()创建一个Builder对象，所以我们来看看这个默认构造方法里都做了些什么事：

public Builder() {
  this(Platform.get());
}

OK，我们再来看看我们前面说到的Platform这个平台类的静态方法get()

//静态实例对象，类加载就确定了
private static final Platform PLATFORM = findPlatform();

  static Platform get() {
    return PLATFORM;
  }

  private static Platform findPlatform() {
    try {
      Class.forName("android.os.Build");
      if (Build.VERSION.SDK_INT != 0) {
        return new Android();
      }
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("java.util.Optional");
      return new Java8();
    } catch (ClassNotFoundException ignored) {
    }
    try {
      Class.forName("org.robovm.apple.foundation.NSObject");
      return new IOS();
    } catch (ClassNotFoundException ignored) {
    }
    return new Platform();
  }
  ...
}

通过上面的代码我们可以很明确的知道，在Platform类加载的时候它就通过反射的机制确定了当前运行的平台是属于哪一个，是Android，是Java8还是IOS，并生成对应的平台类的实例，get()方法是用来获取当前的平台类的实例。

目前，我们只关注Android平台下的Platform实例，我们也来看看Android平台类中做了些什么：

static class Android extends Platform {
    @Override public Executor defaultCallbackExecutor() {
      return new MainThreadExecutor();
    }

    @Override CallAdapter.Factory defaultCallAdapterFactory(Executor callbackExecutor) {
      return new ExecutorCallAdapterFactory(callbackExecutor);
    }

    static class MainThreadExecutor implements Executor {
      private final Handler handler = new Handler(Looper.getMainLooper());

      @Override public void execute(Runnable r) {
        handler.post(r);
      }
    }
  }

可以看到Android类中重写了Platform类的两个方法defaultCallbackExecutor()和defaultCallAdapterFactory(Executor callbackExecutor)
1. 前者就是用来返回当前平台下默认的Executor，这Android平台下就是MainThreadExecutor这个类的实例，可以看到这个执行器主要就是用来进行线程切换的，因为我们知道安卓平台下所有的UI操作都必须在UI线程中执行。
2. 后者就是用来返回当前平台下默认的CallAdapter.Factory
3. 当然你也可以不使用这两个默认值，都可以在创建Retrofit过程中自定义配置自己需要的相关实例

Retrofit创建流程 >> ExecutorCallAdapterFactory

看完Platform之后紧接着我们再来看看Android平台下默认的CallAdapter.Factory实现ExecutorCallAdapterFactory都做了些什么，这里只贴关键代码：

public interface CallAdapter<T> {
    abstract class Factory {
        public abstract CallAdapter<?> get(Type returnType, Annotation[] annotations,
            Retrofit retrofit);
        ...
    }
}

final class ExecutorCallAdapterFactory extends CallAdapter.Factory {
  final Executor callbackExecutor;//对应默认的MainThreadExecutor

  ExecutorCallAdapterFactory(Executor callbackExecutor) {
    this.callbackExecutor = callbackExecutor;
  }

  @Override
  public CallAdapter<Call<?>> get(Type returnType, Annotation[] annotations, Retrofit retrofit) {
    ...
    return new CallAdapter<Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public <R> Call<R> adapt(Call<R> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };
  }
  ...
}

大家看源码可以发现CallAdapter.Factory工厂是通过get()方法来创建CallAdapter的，所以ExecutorCallAdapterFactory关键代码也是在get()方法的实现上，上面的代码中我们可以看到get()方法返回一个CallAdapter实例，这就是我前面介绍关键类作用时说到的CallAdapter.Factory主要负责生成CallAdapter的实现。

该类中，我们从其类的命名以及代码实现结构上来看，ExecutorCallAdapterFactory其实也使用了一种设计模式，那就是工厂方法模式，其实Retrofit中还有一个地方也使用了工厂方法模式，那就是Converter & Converter.Factory它的实现方式和CallAdapter & CallAdapter.Factory是一样样的。

工厂方式模式(创建CallAdapter & Converter)

本文我就已CallAdapter进行举例，看懂CallAdapter的创建原理之后，再看Converter的创建也就比较简单，都是一样的道理。

Retrofit场景

Retrofit中使用工厂方式模式的场景我在前面讲ExecutorCallAdapterFactory实现的时候已经讲过了，这里就不重复举例了，大家可以对照着源码看下。

工厂方法模式定义

一个用于创建对象的接口，让子类决定实例化哪个类

工厂方法模式使用场景

1. 不需要知道其具体的类名，只需要知道生成它的工厂
2. 一个类通过其子类来决定创建哪个对象

工厂方法模式类图

Retrofit中的工厂方法

1. Retrofit中使用工厂方法模式可以讲CallAdapter的创建与具体实现充分解耦，对于创建我们只需要知道其工厂即可，不需要关注是如何实现
2. 所以我们可以通过addCallAdapterFactory()和addConverterFactory()很方便的自定义我们自己所需要的适配器工厂和数据转换工厂
3. 通过addCallAdapterFactory()可以很方便的让Retrofit支持RxJava特性，而通过addConverterFactory()可以自定义配置们想要的转换器，让我们可以将请求数据结果转换成我们想要的任意类型。

这些就是Retrofit使用工厂方法模式带来的好处。

工厂方法模式优缺点

• 优点
  
  1. 只关注产品工厂即可，不需要关注产品如何创建，由工厂确定如何创建
  2. 扩展性好，新增产品时，只需要新增一个具体工厂和具体产品
• 缺点
  
  1. 新增产品时，需要新增具体工厂和具体产品类，使系统变得庞大
  2. 系统中加入抽象层，增加了系统的抽象性和理解难度

适配器模式 >> CallAdapter

Retrofit场景

先来看看CallAdapter在Retrofit中的使用场景

public interface CallAdapter<T> {
    public Type responseType();

    public <R> Call<R> adapt(Call<R> call);
}

//ExecutorCallAdapterFactory中生成CallAdapter实例
return new CallAdapter<Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public <R> Call<R> adapt(Call<R> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };

前面讲到ExecutorCallAdapterFactory会生成一个CallAdapter实例。而CallAdapter这个名字看着是不是也很眼熟，也有种似曾相识的感觉，没错，CallAdapter与我们在Android中使用ListView或RecyclerView时经常用到的各种Adapter一样也是一个适配器。

那CallAdapter是来适配什么的呢？

还记得前面介绍关键类的时候说到的OkHttpCall吗？CallAdapter就是来适配OkHttpCall实例的，结合上面的代码来说的话在调用CallAdapter.adapt方法时OkHttpCall实例会作为参数传递给adapt方法从而交给CallAdapter去进行适配。

在我前面举的登录示例中，我们调用login()方法得到的Call实例就是CallAdapter适配OkHttpCall之后得到的一个新Call实例对象，至于为什么是这样，我后面会一一讲解，各位看官不要离开

所以Retrofit在这个地方又使用了一种设计模式：适配器模式

适配器模式定义

将一个类的接口变成客户端所需要的另一个接口，从而使原本因接口不匹配而无法一起工作的两个类可以在一起工作

适配器模式使用场景

1. 需要复用现有类，而现有类不符合系统需求
2. 需要一个统一的输出接口，而输入端类型不可预知

适配器模式类图

Retrofit中的适配器模式

//ExecutorCallAdapterFactory中生成CallAdapter实例
return new CallAdapter<Call<?>>() {
      @Override public Type responseType() {
        return responseType;
      }

      @Override public <R> Call<R> adapt(Call<R> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };

Android平台下默认的CallAdapter会将OkHttpCall 和 MainThreadExecutor两个实例对象适配成一个新的Call实例，这个新的Call实例在执行过程中就具备了切换到UI线程的功能。

那Retrofit在这个地方为什么要使用适配器模式将OkHttpCall进行适配了，直接拿过来用不就可以了吗？

前面讲过OkHttpCall仅仅只是对OkHttp.Call执行网络请求操作的封装，没有其他功能，也就是说OkHttpCall也只有网络请求的功能，而Retrofit是支持多个平台的（安卓，Java8，IOS，甚至包括支持RxJava特性），而不同的平台可能具有不同的特性。

如果在请求过程中需要用到这些特性的话，那么单靠OkHttp.Call是无法完成的，而如果在其他地方柔和进这些特性的支持可能就会使得框架结构不那么严谨平台解耦性比较差，甚至有可能会增加更多的接口。

Retrofit通过使用适配器模式将平台特性与OkHttpCall适配成一个最终我们需要的Call实例，这样的话我们在使用过程中只需要关注最后拿到的Call对象，而不需要关注底层这个Call实例到底是什么样的，这也就为我们支持更多的特性提供了可能。比如对RxJava特性的支持，我们只需要提供一个支持RxJava特性的CallAdapter适配器即可，所以我们就可以通过addCallAdapterFactory()配置我们提供的支持RxJava特性的CallAdapter.Factory

适配器模式优缺点

• 优点
  
  1. 复用性好，引入适配器类来重用适配者类，无需修改原有代码
  2. 增加类的透明性，将适配过程封装在适配器类中，对使用者来说相对透明
  3. 灵活性扩展性好，通过配置可以随时更换适配器
• 缺点
  
  1. 使用适配器会使系统整体不好把握，调的是A接口，却被适配成了B接口的实现

静态代理模式 >> ExecutorCallbackCall

Retrofit场景

还是先来看看Retrofit中使用ExecutorCallbackCall的场景

//ExecutorCallAdapterFactory中生成CallAdapter实例
return new CallAdapter<Call<?>>() {
      ...
      @Override public <R> Call<R> adapt(Call<R> call) {
        return new ExecutorCallbackCall<>(callbackExecutor, call);
      }
    };

在上面CallAdapter实现中，可以发现它将OkHttpCall适配成了一个新的Call实例：ExecutorCallbackCall，所以我们接着看看ExecutorCallbackCall的具体实现代码

static final class ExecutorCallbackCall<T> implements Call<T> {
    final Executor callbackExecutor;//Android平台下的Executor：MainThreadExecutor
    final Call<T> delegate;//网络实际执行者OkHttpCall实例

    ExecutorCallbackCall(Executor callbackExecutor, Call<T> delegate) {
      this.callbackExecutor = callbackExecutor;
      this.delegate = delegate;
    }

    @Override public void enqueue(final Callback<T> callback) {
      if (callback == null) throw new NullPointerException("callback == null");

      delegate.enqueue(new Callback<T>() {
        @Override public void onResponse(Call<T> call, final Response<T> response) {
          //Android平台下此处进行了线程切换
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              if (delegate.isCanceled()) {
                callback.onFailure(ExecutorCallbackCall.this, new IOException("Canceled"));
              } else {
                callback.onResponse(ExecutorCallbackCall.this, response);
              }
            }
          });
        }

        @Override public void onFailure(Call<T> call, final Throwable t) {
          //Android平台下此处进行了线程切换
          callbackExecutor.execute(new Runnable() {
            @Override public void run() {
              callback.onFailure(ExecutorCallbackCall.this, t);
            }
          });
        }
      });
    }

    @Override public boolean isExecuted() {
      return delegate.isExecuted();
    }

    @Override public Response<T> execute() throws IOException {
      return delegate.execute();
    }

    @Override public void cancel() {
      delegate.cancel();
    }

    @Override public boolean isCanceled() {
      return delegate.isCanceled();
    }

    @SuppressWarnings("CloneDoesntCallSuperClone") // Performing deep clone.
    @Override public Call<T> clone() {
      return new ExecutorCallbackCall<>(callbackExecutor, delegate.clone());
    }

    @Override public Request request() {
      return delegate.request();
    }
  }
}

可以看到我们通过login()方法拿到Call实例(也就是ExecutorCallbackCall)之后，在执行网络请求时，在ExecutorCallbackCall的实现中其实都是将具体操作委托给OkHttpCall在执行。所以Retrofit在ExecutorCallbackCall中又使用了一种设计模式：静态代理模式

静态代理模式定义

为其他对象提供一种代理以控制对这个对象的访问

静态代理模式使用场景

无法访问或不想直接访问某个对象

静态代理模式类图

Retrofit中的静态代理

Retrofit中使用ExecutorCallbackCall代理OkHttpCall具体请求操作，可以将Call的使用与底层实现进行解耦，不用关心底层具体请求接口的实现，所以如果将来出现了一个比OkHttp更好的网络请求库，我们完全可以将OkHttp替换掉，即便这样也不会影响外部API接口在项目中的使用。

静态代理的优缺点

• 优点
  
  1. 协调调用者与被调用者，降低系统耦合度
  2. 减小外部接口与内部接口实现的关联，降低耦合
• 缺点
  
  1. 委托对象与代理对象需要实现相同的接口，当接口类增加方法时，除了所有实现类需要增加该方法外，所有代理类也需要实现此方法，增加了维护难度
  2. 一个代理类只能代理一种类型的对象

动态代理 >> Retrofit.create()

先看下Retrofit.create()方法的具体实现代码：

public <T> T create(final Class<T> service) {
    return (T) Proxy.newProxyInstance(service.getClassLoader(), 
        new Class<?>[] { service }, new InvocationHandler() {
      private final Platform platform = Platform.get();
      @Override 
      public Object invoke(Object proxy, Method method, Object... args)
          throws Throwable {
        ...
        ServiceMethod serviceMethod = loadServiceMethod(method);
        OkHttpCall okHttpCall = new OkHttpCall<>(serviceMethod, args);
        return serviceMethod.callAdapter.adapt(okHttpCall);
      }
    });
}

相信很多人在刚开始用Retrofit时都会有一点疑问，我们明明声明的是接口，为什么通过create()方法就能创建出一个对象实例呢？
通过上面的实现源码我们找到了答案，那就是使用了JDK中提供的动态代理机制，它会在运行过程中为我们声明的服务接口动态的创建出一个代理对象，以便实现我们的请求操作。我个人认为这是Retrofit框架得以实现的一个核心之处，另外一个核心之处就是其完善的注解机制，关于其注解本文就不说，主要就是一些注解的声明和解析，比较简单，感兴趣的可以去看看。

上面的源码中我们可以看到，运行过程中得到服务接口的代理对象之后，当我们调用login()这样的接口方法时，其实真实执行的是上面源码中写的invoke()方法，所以我们调用login()方法时其实是执行了如下三步：
1. 根据反射得到接口方法Method对象生成对应的ServiceMethod对象，该对象会对该声明方法上的所有方法注解、参数注解进行解析以得到一个请求所需要的所有信息
2. 得到ServiceMethod对象之后，会根据该对象和方法调用时传递的参数生成OkHttpCall对象，也就是具体的网络实施者
3. 将OkHttpCall作为CallAdapter适配器中adapt()方法的参数传递给CallAdapter进行适配，最后得到我们所需要的ExecutorCallbackCall对象，也就是调用login()方法得到的Call实例对象

动态代理使用场景

静态代理特点一个代理对应一种类型，如果有多个类需要代理则需要多个代理，而且维护成本高，而动态代理就是来解决此类问题

动态代理特点

运行期由JVM通过反射机制动态生成，可以代理多种类型，代码复用性高。但是只能代理Java接口，不能代理Java实现类。

Call.enqueue() & Call.execute()实现

前面从Retrofit的配置、创建、调用接口方法得到Call实例，基本用法都已经讲的差不多了，现在我们来看基本用法的最后一步Call.enqueue() & Call.execute()

前面讲过调用接口方法比如login()时，Android平台下默认得到的是ExecutorCallbackCall实例，而ExecutorCallbackCall实例中执行网络请求的实际上又是OkHttpCall，所以我们来看OkHttpCall中的Call.enqueue() & Call.execute()两个方法的实现，我以Call.enqueue()为例，另外一个大家可以自己去看看

下面是该方法实现的关键代码：

OkHttpCall.enqueue()

@Override public void enqueue(final Callback<T> callback) {
    ...
    okhttp3.Call call;
    Throwable failure;

    synchronized (this) {
      if (executed) throw new IllegalStateException("Already executed.");
      executed = true;

      call = rawCall;
      failure = creationFailure;
      if (call == null && failure == null) {
        try {
          //如果okhttp3.Call为空，则先创建该实例
          call = rawCall = createRawCall();
        } catch (Throwable t) {
          failure = creationFailure = t;
        }
      }
    }
    ...
    //又讲网络执行转交给okhttp3.Call实例来执行
    call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response<T> response;
        try {
          //将okhttp3.Response结果包装成Retrofit中的结果对象Response
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }

      @Override public void onFailure(okhttp3.Call call, IOException e) {
        ...
      }

      private void callFailure(Throwable e) {
        ...
      }

      private void callSuccess(Response<T> response) {
        ...
      }
    });
  }

前面介绍关键类时说过OkHttpCall底层网络执行其实是OkHttp.Call在执行，从上面的代码我们就可以看出来(代码关键地方我加了注释)，上面代码关键第一步是先创建一个okhttp3.call实例，所以我们同样看看创建okhttp3.call实例的代码是怎么实现的

private okhttp3.Call createRawCall() throws IOException {
    Request request = serviceMethod.toRequest(args);
    okhttp3.Call call = serviceMethod.callFactory.newCall(request);
    ...
    return call;
  }

通过上面的createRawCall()方法实现我们可以发现，它会首先通过ServiceMethod.toRequest()方法生成一个OkHttp.Request对象(这部分代码比较简单，我就不细说了)，然后根据ServiceMethod中的成员变量CallFactory创建一个okhttp3.Call实例。但是这个CallFactory是怎么来的呢？其实我们可以猜到这个CallFactory实例就是OkHttpClient实例。但是我们还是看看ServiceMethod的创建过程

ServiceMethod创建

//在Retrofit.create()方法实现的第一步就是通过loadServiceMethod()方法创建ServiceMethod，这是其实现
ServiceMethod loadServiceMethod(Method method) {
    ServiceMethod result;
    synchronized (serviceMethodCache) {
      result = serviceMethodCache.get(method);
      if (result == null) {
        result = new ServiceMethod.Builder(this, method).build();
        serviceMethodCache.put(method, result);
      }
    }
    return result;
  }

//下面是ServiceMethod相关关键代码
final class ServiceMethod<T> {
    final okhttp3.Call.Factory callFactory;
    ServiceMethod(Builder<T> builder) {
        this.callFactory = builder.retrofit.callFactory();
        this.callAdapter = builder.callAdapter;
        this.baseUrl = builder.retrofit.baseUrl();
        this.responseConverter = builder.responseConverter;
        ...
      }

    static final class Builder {
        public Builder(Retrofit retrofit, Method method) {
          this.retrofit = retrofit;
          this.method = method;
          ...
        }
        public ServiceMethod build() {
              //创建CallAdapter
              callAdapter = createCallAdapter();
              //得到请求结果返回类型，接口方法声明
              responseType = callAdapter.responseType();
              ...
              //创建得到Converter结果转换器
              responseConverter = createResponseConverter();
              ...
              return new ServiceMethod<>(this);
        }
    }
}

通过上面的ServiceMethod创建过程的相关代码可以看出，ServiceMethod中的实例变量callFactory其实是调用Retrofit.callFactory()方法所得，大家也可以看看上面我注释的CallAdapter和Converter的创建过程，所以我们再来看看这个方法的实现

public okhttp3.Call.Factory callFactory() {
    return callFactory;
}

可以看到该方法只是返回了Retrofit中的callFactory实例，同样，我们再来看看Retrofit中的callFactory实例是怎么来的

public final class Retrofit {
    private final okhttp3.Call.Factory callFactory;
    ...

    Retrofit(okhttp3.Call.Factory callFactory, ...) {
        this.callFactory = callFactory;
        ...
    }

    public static final class Builder {
        private okhttp3.Call.Factory callFactory;
        ...
        public Builder client(OkHttpClient client) {
          return callFactory(checkNotNull(client, "client == null"));
        }

        public Builder callFactory(okhttp3.Call.Factory factory) {
          this.callFactory = checkNotNull(factory, "factory == null");
          return this;
        }

        public Retrofit build() {
          ...
          okhttp3.Call.Factory callFactory = this.callFactory;
          if (callFactory == null) {
            callFactory = new OkHttpClient();
          }
          ...
          return new Retrofit(callFactory, ...);
        }
    }
}

通过上面的代码，我们可以看出Retrofit中的callFactory实例就是我们使用的OkHttpClient实例，所以这就验证了我们前面猜测的serviceMethod.callFactory就是OkHttpClient实例的猜想。

Ok，回到我们前面将的OkHttpCall.equeue()方法的实现流程上来。

请求结果解析

call.enqueue(new okhttp3.Callback() {
      @Override public void onResponse(okhttp3.Call call, okhttp3.Response rawResponse)
          throws IOException {
        Response<T> response;
        try {
          //将okhttp3.Response结果包装成Retrofit中的结果对象Response
          response = parseResponse(rawResponse);
        } catch (Throwable e) {
          callFailure(e);
          return;
        }
        callSuccess(response);
      }
      ...
}

创建完okhttp3.call实例之后，调用该实现的equeue()方法开始执行网络请求，请求执行完成之后，会调用parseResponse方法，我们来看看这个方法实现的关键代码：

Response<T> parseResponse(okhttp3.Response rawResponse) throws IOException {
    ResponseBody rawBody = rawResponse.body();
    ...
    //上面省略的这段代码是对请求失败时的结果处理，大家可以自行查看源码

    ExceptionCatchingRequestBody catchingBody = new ExceptionCatchingRequestBody(rawBody);
    try {
      T body = serviceMethod.toResponse(catchingBody);
      return Response.success(body, rawResponse);
    } catch (RuntimeException e) {
      catchingBody.throwIfCaught();
      throw e;
    }
  }

这个方法中，当请求成功时，会调用serviceMethod.toResponse()这个方法，我们来看看这个方法又做了哪些事情：

T toResponse(ResponseBody body) throws IOException {
    return responseConverter.convert(body);
}

很明显，上面方法中就直接调用了ServiceMethod中的Converter实例进行结果转换，也就是说在这个地方Retrofit会帮我们把网络请求结果转换成我们所需要的类型，转换成功之后会调用Response.success(body, rawResponse)将转换后的结果包装成Retrofit中的Response对象。

获取配置的Converter

问题又来了，上面的Converter是怎么来的呢？

在前面给出的ServiceMethod创建过程的代码块中，我对ServiceMethod中创建Converter实例的代码进行了注释，我们再回过头来看看这段代码：

//ServiceMethod.Buibler中的方法
private Converter<ResponseBody, T> createResponseConverter() {
      ...
      try {
        return retrofit.responseBodyConverter(responseType, annotations);
      } catch (RuntimeException e) { // Wide exception range because factories are user code.
        throw methodError(e, "Unable to create converter for %s", responseType);
      }
    }

//Retrofit中的方法
public <T> Converter<ResponseBody, T> responseBodyConverter(Type type, Annotation[] annotations) {
    return nextResponseBodyConverter(null, type, annotations);
  }

public <T> Converter<ResponseBody, T> nextResponseBodyConverter(Converter.Factory skipPast,
      Type type, Annotation[] annotations) {
    ...
    int start = converterFactories.indexOf(skipPast) + 1;
    for (int i = start, count = converterFactories.size(); i < count; i++) {
      Converter<ResponseBody, ?> converter =
          converterFactories.get(i).responseBodyConverter(type, annotations, this);
      if (converter != null) {
        return (Converter<ResponseBody, T>) converter;
      }
    }
    ...
    throw new IllegalArgumentException(builder.toString());
  }

通过上面的代码我们可以看到会从Retrofit的converterFactories转换器工厂集合中去查找当前接口方法对应的转换器工厂。其实这也告诉我们可以在创建Retrofit时配置多个Converter.Factory转换器工厂，也就是说我们一个接口服务中如果声明的多个接口方法的返回值不一样时，我们可以针对性的配置多个不一样的结果转换器工厂去进行结果解析，而不用为了保持结果类型一致对接口进行其他处理。

上面创建ServiceMethod时得到CallAdapter的过程与得到Converter的过程基本一样，我就不赘述了。

到这里，Retrofit的实现原理、实现流程以及其源码实现过程中用到的设计模式就介绍完了。

内容好长，时间好长~~~~

欢迎访问我的独立博客：http://ittiger.cn

学习一个东西首先要知道为什么要引入它，就是我们能用它来干什么。所以我们先来看看ThreadLocal对我们到底有什么用，然后再来看看它的实现原理。

ThreadLocal如果单纯从名字上来看像是“本地线程"这么个意思，只能说这个名字起的确实不太好，很容易让人产生误解，ThreadLocalVariable（线程本地变量）应该是个更好的名字。我们先看一下官方对ThreadLocal的描述：

该类提供了线程局部 (thread-local) 变量。这些变量不同于它们的普通对应物，因为访问某个变量（通过其 get 或 set 方法）的每个线程都有自己的局部变量，它独立于变量的初始化副本。ThreadLocal 实例通常是类中的 private static 字段，它们希望将状态与某一个线程（例如，用户 ID 或事务 ID）相关联。

1、每个线程都有自己的局部变量

    每个线程都有一个独立于其他线程的上下文来保存这个变量，一个线程的本地变量对其他线程是不可见的（有前提，后面解释）

2、独立于变量的初始化副本

    ThreadLocal可以给一个初始值，而每个线程都会获得这个初始化值的一个副本，这样才能保证不同的线程都有一份拷贝。

3、状态与某一个线程相关联

    ThreadLocal 不是用于解决共享变量的问题的，不是为了协调线程同步而存在，而是为了方便每个线程处理自己的状态而引入的一个机制，理解这点对正确使用ThreadLocal至关重要。

我们先看一个简单的例子：

Thread-0 : 5
Thread-4 : 5
Thread-2 : 5
Thread-1 : 5
Thread-3 : 5

我们看到，每个线程累加后的结果都是5，各个线程处理自己的本地变量值，线程之间互不影响。

我们再来看一个例子：

Thread-0 : 1390
Thread-2 : 2390
Thread-4 : 4390
Thread-3 : 3491
Thread-1 : 1390

这次为什么线程本地变量又失效了呢？大家可以仔细观察上面代码自己先找一下原因。

-----------------------------------------------低调的分割线-------------------------------------------

让我们再来回味一下 “ThreadLocal可以给一个初始值，而每个线程都会获得这个初始化值的一个副本” 这句话。“初始值的副本。。。”，貌似想起点什么。我们再来看一下上面代码中定义ThreadLocal的地方

 上面代码中，我们通过覆盖initialValue函数来给我们的ThreadLocal提供初始值，每个线程都会获取这个初始值的一个副本。而现在我们的初始值是一个定义好的一个对象，num是这个对象的引用.换句话说我们的初始值是一个引用。引用的副本和引用指向的不就是同一个对象吗？

如果我们想给每一个线程都保存一个Index对象应该怎么办呢？那就是创建对象的副本而不是对象引用的副本：

对象的拷贝图示：

现在我们应该能明白ThreadLocal本地变量的含义了吧。接下来我们就来看看ThreadLocal的源码，从内部来揭示它的神秘面纱。

ThreadLocal有一个内部类ThreadLocalMap,这个类的实现占了整个ThreadLocal类源码的一多半。这个ThreadLocalMap的作用非常关键，它就是线程真正保存线程自己本地变量的容器。每一个线程都有自己的单独的一个ThreadLocalMap实例，其所有的本地变量都会保存到这一个map中。

在上面谈到了对ThreadLocal的一些理解，那我们下面来看一下具体ThreadLocal是如何实现的。

　　先了解一下ThreadLocal类提供的几个方法：

 　　get()方法是用来获取ThreadLocal在当前线程中保存的变量副本，set()用来设置当前线程中变量的副本，remove()用来移除当前线程中变量的副本，initialValue()是一个protected方法，一般是用来在使用时进行重写的，它是一个延迟加载方法，下面会详细说明。

强调一下：Thread对象都有一个ThreadLocalMap类型的属性threadLocals，这个属性是专门用于保存自己所有的线程本地变量的。这个属性在线程对象初始化的时候为null。所以对一个线程对象第一次使用线程本地变量的时候，需要对这个threadLocals属性进行初始化操作。注意要区别 “线程第一次使用本地线程变量”和“第一次使用某一个线程本地线程变量”。

getMap方法:

//直接返回线程对象的threadLocals属性

setInitialValue方法：（看完后再回顾一下之前的那个例子）

我们再来看一下set方法

ThradLocal还有一个remove方法，让我们来分析一下:

到这里大家应该对ThreadLocal变量比较清晰了，至于ThradLocalMap的实现细节这里就不在说了。大家有兴趣可以自己去看ThreadLocal的源码。

总之，ThreadLocal不是用来解决对象共享访问问题的，而主要是提供了保持对象的方法和避免参数传递的方便的对象访问方式。归纳了两点： 
1。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。 
2。将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。 

数组使用有序列表存储同一类型的多个值，且相同的值可以多次出现在一个数组的不同位置中。

数组会强制检测元素的类型，如果类型不同则会报错，Swift数组应该遵循像Array<Element>这样的形式，其中Element是这个数组中唯一允许存在的数据类型。

如果创建一个数组，并赋值给一个变量，则创建的集合就是可以修改的。这意味着在创建数组后，可以通过添加、删除、修改的方式改变数组里的项目。如果将一个数组赋值给常量，数组就不可更改，并且数组的大小和内容都不可以修改。

使用注意事项： 数组初始化时定义了的元素类型后，在后续使用中，元素类型必须是统一的。但如果定义了类型为"Any"，或"AnyObject"时，则数组中可以使用任意类型的元素，同时"Any"类型时，还可以包含方法selector类。

[objc] view plain copy

 

1. // 空数组  
2. let arrayTmp01 = Array<String>()  
3. print(arrayTmp01)  
4.           
5. let arrayTmp02 = [String]()  
6. print(arrayTmp02)  
7.           
8. let arrayTmp03:Array<String> = []  
9. print(arrayTmp03)  

[objc] view plain copy

 

1. // 数组清空  
2. var arrayTmp04 = ["1", "2"]  
3. print(arrayTmp04)  
4.           
5. arrayTmp04 = []  
6. print(arrayTmp04)  
7.           
8. arrayTmp04 = ["1", "2"]  
9. print(arrayTmp04)  
10.           
11. arrayTmp04 = Array<String>()  
12. print(arrayTmp04)  

[objc] view plain copy

 

1. // 创建数组  
2. let array01:[Int] = [1,2,3,4,5]  
3. print(array01)  
4.           
5. let array02 = ["1", "2", "3"]  
6. print(array02)  
7.           
8. let array03 = [array01, array02]  
9. print(array03)  

[objc] view plain copy

 

1. // 读取数组元素值  
2. let value01 = array01[0]  
3. print(value01)  
4.           
5. let value02 = array01.indexOf(1)  
6. print(value02)  
7.           
8. for value in array01  
9. {  
10.  print("value = \(value)")  
11. }  
12.           
13. for var index = 0; index < array01.count; index++  
14. {  
15.  let value = array01[index]  
16.  print("index = \(index), value = \(value)")  
17. }  
18.           
19. for i in 0..<array01.count  
20. {  
21.  print(array01[i])  
22. }  
23.           
24. for (index, item) in array01.enumerate()  
25. {  
26.  print("在 index = \(index) 位置上的值为 \(item)")  
27. }  

[objc] view plain copy

 

1. // 修改数组  
2. var array04 = [10,20,30]  
3. // 添加元素（添加到最后）  
4. array04.append(100) // 单个元素  
5. print(array04)  
6. array04 = array04 + [200] // 元素数组  
7. print(array04)  
8. array04.appendContentsOf([201,202]) // 元素集合  
9. print(array04)  
10. array04.appendContentsOf(203...210) // 元素序列  
11. print(array04)  

[objc] view plain copy

 

1. // 添加元素（添加到指定位置）</span>  

[objc] view plain copy

 

1. array04.insert(500, atIndex: 2)  
2. print(array04)  

[objc] view plain copy

 

1. // 修改元素  
2. array04[4] = 300  
3. print(array04)  

[objc] view plain copy

 

1. // 删除元素  
2. array04.removeFirst()  
3. print(array04)  
4.           
5. array04.removeLast()  
6. print(array04)  
7.           
8. array04.removeAtIndex(0)  
9. print(array04)  
10.           
11. array04.removeAll()  
12. print(array04)  

[objc] view plain copy

 

1. // 合并数组（注意：数组类型必须一致）  
2. array04 = array01 + [100,200,300]  
3. print(array04)  

[objc] view plain copy

 

1. // 类型判断  
2. var isArray:Bool = array01 is Array  
3. if isArray  
4. {  
5.  print("array01 is array class")  
6. }  
7. else  
8. {  
9.  print("array01 is not array class")  
10. }  

[objc] view plain copy

 

1. // 数组元素个数  
2. let count01 = array04.count  
3. print(count01)  

[objc] view plain copy

 

1. // 判断数组是否为空  
2. let isValid = array04.isEmpty  
3. print(isValid)  

[objc] view plain copy

 

1. // 第一个元素  
2. let item01 = array04.first  
3. print(item01)  

[objc] view plain copy

 

1. // 最后一个元素  
2. let item02 = array04.last  
3. print(item02)  

[objc] view plain copy

 

1. // 是否包含某个元素  
2. let contant1:Bool = array01.contains(1)  
3. print("array01 \(contant1) 包含 1")  

[objc] view plain copy

 

1. // 数组排序   
2. let arraySort = array04.sort({(n1:Int, n2:Int)->Bool in  
3.  // 从小到大  
4.  // return n2 > n1  
5.               
6.  // 从大到小  
7.  return n2 < n1  
8. })  
9. print(arraySort)  
10.           
11. let arraySort02 = array04.sort({  
12.  // 从小到大  
13.  // return $1 > $0  
14.               
15.  // 从大到小  
16.  return $1 < $0  
17. })  
18. print(arraySort02)  
19.           
20. let arraySort03 = array04.sort(){  
21.  // 从小到大  
22.  // $1 > $0  
23.               
24.  // 从大到小  
25.  $1 < $0  
26. }  
27. print(arraySort03)  

补充：Any类型元素，或AnyObject类型元素的数组

[objc] view plain copy

 

1. // 方法selector  
2. func buttonClick() -> Void  
3. {  
4.             print("点击")  
5. }  
6. print(buttonClick)  
7.           
8. // AnyObject任意类型元素的数组（不包含方法selector）  
9. let arrayAnyObject01:Array<AnyObject> = [Grade0ne(chinese: "86", maths: "66"), GradeTwo(chinese: "78", english: "92"), "DevZhang", 30]  
10. print(arrayAnyObject01)  
11.   
12. // Any任意类型元素的数组（包含方法selector）  
13. let arrayAnyObject02:Array<Any> = [Grade0ne(chinese: "86", maths: "66"), GradeTwo(chinese: "78", english: "92"), "DevZhang", 30, buttonClick()]  
14. print(arrayAnyObject02)  

Swift 字典用来存储无序的相同类型数据的集合，Swift字典会强制检测元素的类型，如果类型不同则会报错。

Swift字典每个值（value）都关联唯一的键（key），键作为字典中的这个值数据的标识符。

和数组中的数据项不同，字典中的数据项并没有具体顺序。我们在需要通过标识符（键）访问数据的时候使用字典，这种方法很大程度上和我们在现实世界中使用字典查字义的方法一样。

Swift字典的key没有类型限制可以是整型或字符串，但必须是唯一的。

如果创建一个字典，并赋值给一个变量，则创建的字典就是可以修改的。这意味着在创建字典后，可以通过添加、删除、修改的方式改变字典里的项目。如果将一个字典赋值给常量，字典就不可修改，并且字典的大小和内容都不可以修改。

[objc] view plain copy

 

1. // 创建字典  
2. // 创建一个特定类型的空字典，格式为：var dict = [KeyType: ValueType]()  
3. // 创建一个空字典，键的类型为 Int，值的类型为 String 的简单语法：  
4. var dict01 = [Int: String]()  
5. print(dict01)  
6.           
7. // 创建一个字典的实例：  
8. var dict02 :[Int:String] = [1:"One", 2:"Two", 3:"Three"]  
9. print(dict02)  
10.           
11. var dict03 = ["name":"DevZhang", "job":"iOSDev", "company":"VSTECS"]  
12. print(dict03)  

[objc] view plain copy

 

1. // 访问字典  
2. // 我们可以根据字典的索引来访问数组的元素，语法如下：var value = dict[key]  
3. let value01 = dict02[1]  
4. print(value01)  
5.           
6. let value02 = dict03["name"]  
7. print(value02)  

[objc] view plain copy

 

1. // 添加数据  
2. let value03 = dict02.updateValue("Four", forKey: 4)  //或 dict02[4] = "Four"  
3. print(value03)  
4. print(dict02)  

[objc] view plain copy

 

1. // 修改字典  
2. // 方法1 使用 updateValue(forKey:) 增加或更新字典的内容。如果 key 不存在，则添加值，如果存在则修改 key 对应的值。格式为：dict.updateValue(value, forKey:key)方法返回Optional值。  
3. var value04 = dict02.updateValue("TwoTmp", forKey: 2)  
4. print(dict02)  
5. print(value04)  
6.    
7. // 方法2 通过指定的 key 来修改字典的值  
8. var value05 = dict02[3]  
9. print(value05)  
10. value05 = "ThreeTmp" // 修改无效  
11. print(dict02)  
12. dict02[3] = "ThreeTmp" // 修改有效  
13. print(dict02)  

[objc] view plain copy

 

1. // 移除 Key-Value 对  
2. // 1 使用 removeValueForKey() 方法来移除字典 key-value 对。如果 key 存在该方法返回移除的值，如果不存在返回 nil 。  
3. let valueRemove01 = dict02.removeValueForKey(2)  
4. print(valueRemove01)  
5. print(dict02)  
6.           
7. // 2 通过指定键的值为 nil 来移除 key-value（键-值）对。  
8. dict02[1] = nil  
9. print(dict02)  

[objc] view plain copy

 

1. // 遍历字典  
2. // 1 使用 for-in 循环来遍历某个字典中的键值对。  
3. for (key, value) in dict03  
4. {  
5.  print("字典 key \(key) -  字典 value \(value)")  
6. }  
7.           
8. // 2 使用enumerate()方法来进行字典遍历，返回的是字典的索引及 (key, value) 对  
9. for (key, value) in dict03.enumerate()  
10. {  
11.  print("字典 key \(key) -  字典 (key, value) 对 \(value)")  
12. }  
13.   
14. // 3   
15. for key in dict03.keys  
16. {  
17.  let value = dict03[key]  
18.  print("key = \(key), value = \(value)")  
19. }  

[objc] view plain copy

 

1. // 字典转换为数组  
2. // 提取字典的键值(key-value)对，并转换为独立的数组。  
3. let dictKeys = [String](dict03.keys)  
4. for (key) in dictKeys  
5. {  
6.  print("\(key)")  
7. }  
8.           
9. let dictValues = [String](dict03.values)  
10. for (value) in dictValues  
11. {  
12.  print("\(value)")  
13. }  

[objc] view plain copy

 

1. // count 属性  
2. let count01 = dict03.count  
3. print(count01)  

[objc] view plain copy

 

1. // isEmpty 属性  
2. let empty01 = dict01.isEmpty  
3. print("dict01 is \(empty01)")  
4.           
5. let empty02 = dict03.isEmpty  
6. print("dict03 is \(empty02)")  

这篇博文，我们搭建一个简单SpringMVC的环境，使用非注解形式实现一个HelloWorld实例，从简单入手，逐步深入。

环境准备

我们需要有基本的Java环境，下面只是简单的罗列，不再详细的介绍。

jdk1.6以上
eclipse或者myEclipse
tomcat6以上
我们使用SpringMVC的版本是Spring3.2.0，下图是最基本的jar包：

在spring的官方API文档中，给出了所有jar包作用的概述，现列举常用的包以及相关作用：

org.springframework.aop-3.2.0.RELEASE.jar ：与Aop 编程相关的包
org.springframework.beans-3.2.0.RELEASE.jar ：提供了简捷操作bean 的接口
org.springframework.context-3.2.0.RELEASE.jar ：构建在beans 包基础上，用来处理资源文件及国际化。
org.springframework.core-3.2.0.RELEASE.jar ：spring 核心包
org.springframework.web-3.2.0.RELEASE.jar ：web 核心包，提供了web 层接口
org.springframework.web.servlet-3.2.0.RELEASE.jar ：web 层的一个具体实现包，DispatcherServlet也位于此包中。

后文全部实例都在spring3.2.0版本中进行，为了方便，建议在搭建环境中导入spring3.2.0 的所有jar 包（所有jar 包位于dist 目录下）。

环境准备好了，下面我们开始动手。

编写HelloWorld 实例

步骤一、建立名为SpringMVC_helloworld 的动态web项目，并选择服务器，并导入上面列出的jar 包。
步骤二、编写web.xml 配置文件，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <servlet>
        <servlet-name>springMVC</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>springMVC</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

简要说明：其实DispatcherServlet就是一个Servlet，也是对Http请求进行转发的核心Servlet 。所有.do的请求将首先被DispatcherServlet处理，而DispatcherServlet 它要作的工作就是对请求进行分发（也即是说把请求转发给具体的Controller ）。可以简单地认为，它就是一个总控处理器，但事实上它除了具备总控处理理器对请求进行分发的能力外，还与spring 的IOC 容器完全集成在一起，从而可以更好地使用spring 的其它功能。在这里还需留意< servlet-name> springMVC ，下面步骤三会用到。
3. 步骤三、建立Spring的配置文件，注意上一个步骤中的标签在web.xml中的servlet的名称。DispatcherServlet的初始化后，会在WEB - INF查找一个[servlet-name]-servlet.xml 即springMVC-servlet.xml的文件。它的主要代码如下：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.2.xsd 
        http://www.springframework.org/schema/aop 
        http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">

    <bean id="helloControl" class="com.tgb.controller.HelloWorld"></bean>

    <!-- 处理器映射器 将bean的name作为url进行查找 ，需要在配置Handler时指定beanname（就是url） 
    所有的映射器都实现 HandlerMapping接口。
    -->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" />

    <!--简单url映射  -->
    <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <!-- 对helloControl进行url映射，url是/helloworld.do -->
                <prop key="/helloworld.do">helloControl</prop>
            </props>
        </property>
    </bean>

    <!-- 处理器适配器 所有处理器适配器都实现 HandlerAdapter接口 -->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />

</beans>

说明： helloworld.do的请求将被名为helloControl的bean 进行转发处理。
4. 步骤四、创建一个SpringMVC的控制类，并处理请求，完成HelloWord.java 的编写，代码如下：

package com.tgb.controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class HelloWorld implements Controller{

    @Override
    public ModelAndView handleRequest(HttpServletRequest request,
            HttpServletResponse response) throws Exception {

        ModelAndView mav = new ModelAndView("hello.jsp");
        mav.addObject("message", "Hello World!");
        return mav;
    }
}

说明：ModelAndView 对象是包含视图和业务数据的混合对象，即通过此对象，我们可以知道所返回的相应页面（比如这里返回hello.jsp页面），也可以在相应的页面中获取此对象所包含的业务数据（比如这里message-Hello World!）。
5.步骤五、创建jsp，在当前项目web根目录下编写index.jsp，用于发送请求，hello.jsp用于显示消息，主要代码如下：
用index.jsp里面的超链接发出一个请求到HelloWorldController，并返回到hello.jsp 显示message的信息。

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
    <a href="helloworld.do">SpringMVC,HelloWorld实例</a>
</body>
</html>

<%@ page language="java" contentType="text/html; charset=utf-8"
    pageEncoding="utf-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>Insert title here</title>
</head>
<body>
    世界，你好！
    获取值： ${message }
</body>
</html>

6.步骤六：把项目扔到服务器中，运行服务器，在浏览器中输入http://localhost:8080/SpringMVC_HelloWorld/index.jsp 进行测试。

简析springmvc 工作原理

启动服务器，根据web.xml的配置加载前端控制器（也称总控制器） DispatcherServlet 。在加载时会完成一系列的初始化动作。
根据servlet的映射请求(上面的HelloWorld实例中针对.do 请求)，并参照“控制器配置文件”(即springMVC-servlet.xml 这样的配置文件)，把具体的请求分发给特定的后端控制器进行处理(比如上例会分发给HelloWorld 控制器进行处理)
后端控制器调用相应的逻辑层代码，完成处理并返回视图对象（ ModelAndView ）给前端处理器。
前端控制器根据后端控制器返回的ModelAndView 对象，前端控器器根据视图对象返回具体页面给客户端。
总结

SpringMVC框架的核心是DispatcherServlet，它的作用是将请求分发给不同的后端处理器。Spring的Controller层使用了后端控制器来映射处理器和视图解析器来共同完成Controller层的主要工作。并且spring的Controller层还真正地把业务层处理的数据结果和相应的视图封装成一个对象，即我们后面会经常用到的ModelAndView 对象。

一句话总结springMVC

封装web请求为一个数据对象、调用业务逻辑层来处理数据对象、返回处理数据结果及相应的视图给用户。

一、整体介绍

UIWebView自iOS2就有，WKWebView从iOS8才有，毫无疑问WKWebView将逐步取代笨重的UIWebView。通过简单的测试即可发现UIWebView占用过多内存，且内存峰值更是夸张。WKWebView网页加载速度也有提升，但是并不像内存那样提升那么多。下面列举一些其它的优势：

• 更多的支持HTML5的特性
• 官方宣称的高达60fps的滚动刷新率以及内置手势
• Safari相同的JavaScript引擎
• 将UIWebViewDelegate与UIWebView拆分成了14类与3个协议(官方文档说明)
• 另外用的比较多的，增加加载进度属性：estimatedProgress

二、UIWebView使用说明

1 举例：简单的使用

UIWebView使用非常简单，可以分为三步，也是最简单的用法，显示网页

- (void)simpleExampleTest {
    // 1.创建webview，并设置大小，"20"为状态栏高度
    UIWebView *webView = [[UIWebView alloc] initWithFrame:CGRectMake(0, 20, self.view.frame.size.width, 
self.view.frame.size.height - 20)];
    // 2.创建请求
    NSMutableURLRequest *request =[NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://www.cnblogs.com/mddblog/"]];
    // 3.加载网页
    [webView loadRequest:request];

    // 最后将webView添加到界面
    [self.view addSubview:webView];
}

2 一些实用函数

• 加载函数。

- (void)loadRequest:(NSURLRequest *)request;
- (void)loadHTMLString:(NSString *)string baseURL:(nullable NSURL *)baseURL;
- (void)loadData:(NSData *)data MIMEType:(NSString *)MIMEType textEncodingName:(NSString *)textEncodingName 
baseURL:(NSURL *)baseURL;

UIWebView不仅可以加载HTML页面，还支持pdf、word、txt、各种图片等等的显示。下面以加载mac桌面上的png图片：/Users/coohua/Desktop/bigIcon.png为例

// 1.获取url
NSURL *url = [NSURL fileURLWithPath:@"/Users/coohua/Desktop/bigIcon.png"];
// 2.创建请求
NSURLRequest *request=[NSURLRequest requestWithURL:url];
// 3.加载请求
[self.webView loadRequest:request];

• 网页导航刷新有关函数

// 刷新
- (void)reload;
// 停止加载
- (void)stopLoading;
// 后退函数
- (void)goBack;
// 前进函数
- (void)goForward;
// 是否可以后退
@property (nonatomic, readonly, getter=canGoBack) BOOL canGoBack;
// 是否可以向前
@property (nonatomic, readonly, getter=canGoForward) BOOL canGoForward;
// 是否正在加载
@property (nonatomic, readonly, getter=isLoading) BOOL loading;

3 代理协议使用：UIWebViewDelegate

一共有四个方法

/// 是否允许加载网页，也可获取js要打开的url，通过截取此url可与js交互
- (BOOL)webView:(UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request 
navigationType:(UIWebViewNavigationType)navigationType {

    NSString *urlString = [[request URL] absoluteString];
    urlString = [urlString stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];

    NSArray *urlComps = [urlString componentsSeparatedByString:@"://"];
    NSLog(@"urlString=%@---urlComps=%@",urlString,urlComps);
    return YES;
}
/// 开始加载网页
- (void)webViewDidStartLoad:(UIWebView *)webView {
    NSURLRequest *request = webView.request;
    NSLog(@"webViewDidStartLoad-url=%@--%@",[request URL],[request HTTPBody]);
}
/// 网页加载完成
- (void)webViewDidFinishLoad:(UIWebView *)webView {
    NSURLRequest *request = webView.request;
    NSURL *url = [request URL];
    if ([url.path isEqualToString:@"/normal.html"]) {
        NSLog(@"isEqualToString");
    }
    NSLog(@"webViewDidFinishLoad-url=%@--%@",[request URL],[request HTTPBody]);
    NSLog(@"%@",[self.webView stringByEvaluatingJavaScriptFromString:@"document.title"]);
}
/// 网页加载错误
- (void)webView:(UIWebView *)webView didFailLoadWithError:(NSError *)error {
    NSURLRequest *request = webView.request;
    NSLog(@"didFailLoadWithError-url=%@--%@",[request URL],[request HTTPBody]);

}

4 与js交互

主要有两方面：js执行OC代码、oc调取写好的js代码

• js执行OC代码：js是不能执行oc代码的，但是可以变相的执行，js可以将要执行的操作封装到网络请求里面，然后oc拦截这个请求，获取url里面的字符串解析即可，这里用到代理协议的- (BOOL)webView:(UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request navigationType:(UIWebViewNavigationType)navigationType函数。
• oc调取写好的js代码：这里用到UIwebview的一个方法。示例代码一个是网页定位，一个是获取网页title：

// 实现自动定位js代码, htmlLocationID为定位的位置(由js开发人员给出)，实现自动定位代码，应该在网页加载完成之后再调用
NSString *javascriptStr = [NSString stringWithFormat:@"window.location.href = '#%@'",htmlLocationID];
// webview执行代码
[self.webView stringByEvaluatingJavaScriptFromString:javascriptStr];

// 获取网页的title
NSString *title = [self.webView stringByEvaluatingJavaScriptFromString:@"document.title"]

三、WKWebView使用说明

1 简单使用

与UIWebview一样，仅需三步:记住导入（#import <WebKit/WebKit.h>）

- (void)simpleExampleTest {
    // 1.创建webview，并设置大小，"20"为状态栏高度
    WKWebView *webView = [[WKWebView alloc] initWithFrame:CGRectMake(0, 20, self.view.frame.size.width, 
self.view.frame.size.height - 20)];
    // 2.创建请求
    NSMutableURLRequest *request =[NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://www.cnblogs.com/mddblog/"]];
    // 3.加载网页
    [webView loadRequest:request];

    // 最后将webView添加到界面
    [self.view addSubview:webView];
}

2 一些实用函数

• 加载网页函数
  相比UIWebview，WKWebView也支持各种文件格式，并新增了loadFileURL函数，顾名思义加载本地文件。

/// 模拟器调试加载mac本地文件
- (void)loadLocalFile {
    // 1.创建webview，并设置大小，"20"为状态栏高度
    WKWebView *webView = [[WKWebView alloc] initWithFrame:CGRectMake(0, 20, self.view.frame.size.width, 
self.view.frame.size.height - 20)];
    // 2.创建url  userName：电脑用户名
    NSURL *url = [NSURL fileURLWithPath:@"/Users/userName/Desktop/bigIcon.png"];
    // 3.加载文件
    [webView loadFileURL:url allowingReadAccessToURL:url];
    // 最后将webView添加到界面
    [self.view addSubview:webView];
}

/// 其它三个加载函数
- (WKNavigation *)loadRequest:(NSURLRequest *)request;
- (WKNavigation *)loadHTMLString:(NSString *)string baseURL:(nullable NSURL *)baseURL;
- (WKNavigation *)loadData:(NSData *)data MIMEType:(NSString *)MIMEType characterEncodingName:(NSString *)characterEncodingName 
baseURL:(NSURL *)baseURL;

• 网页导航刷新相关函数
  和UIWebview几乎一样，不同的是有返回值，WKNavigation(已更新)，另外增加了函数reloadFromOrigin和goToBackForwardListItem。
  • reloadFromOrigin会比较网络数据是否有变化，没有变化则使用缓存，否则从新请求。
  • goToBackForwardListItem：比向前向后更强大，可以跳转到某个指定历史页面

@property (nonatomic, readonly) BOOL canGoBack;
@property (nonatomic, readonly) BOOL canGoForward;
- (WKNavigation *)goBack;
- (WKNavigation *)goForward;
- (WKNavigation *)reload;
- (WKNavigation *)reloadFromOrigin; // 增加的函数
- (WKNavigation *)goToBackForwardListItem:(WKBackForwardListItem *)item; // 增加的函数
- (void)stopLoading;

• 一些常用属性
  • allowsBackForwardNavigationGestures：BOOL类型，是否允许左右划手势导航，默认不允许
  • estimatedProgress：加载进度，取值范围0~1
  • title：页面title
  • .scrollView.scrollEnabled：是否允许上下滚动，默认允许
  • backForwardList：WKBackForwardList类型，访问历史列表，可以通过前进后退按钮访问，或者通过goToBackForwardListItem函数跳到指定页面

3 代理协议使用

一共有三个代理协议：

• WKNavigationDelegate：最常用，和UIWebViewDelegate功能类似，追踪加载过程，有是否允许加载、开始加载、加载完成、加载失败。下面会对函数做简单的说明，并用数字标出调用的先后次序：1-2-3-4-5

三个是否允许加载函数：

/// 接收到服务器跳转请求之后调用 (服务器端redirect)，不一定调用
- (void)webView:(WKWebView *)webView didReceiveServerRedirectForProvisionalNavigation:(WKNavigation *)navigation; 
/// 3 在收到服务器的响应头，根据response相关信息，决定是否跳转。decisionHandler必须调用，来决定是否跳转，
//参数WKNavigationActionPolicyCancel取消跳转，WKNavigationActionPolicyAllow允许跳转
- (void)webView:(WKWebView *)webView decidePolicyForNavigationResponse:(WKNavigationResponse *)navigationResponse 
decisionHandler:(void (^)(WKNavigationResponsePolicy))decisionHandler;
/// 1 在发送请求之前，决定是否跳转 
- (void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction 
decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler;

追踪加载过程函数:

/// 2 页面开始加载
- (void)webView:(WKWebView *)webView didStartProvisionalNavigation:(WKNavigation *)navigation;
/// 4 开始获取到网页内容时返回
- (void)webView:(WKWebView *)webView didCommitNavigation:(WKNavigation *)navigation;
/// 5 页面加载完成之后调用
- (void)webView:(WKWebView *)webView didFinishNavigation:(WKNavigation *)navigation;
/// 页面加载失败时调用
- (void)webView:(WKWebView *)webView didFailProvisionalNavigation:(WKNavigation *)navigation;

• WKScriptMessageHandler：必须实现的函数，是APP与js交互，提供从网页中收消息的回调方法

/// message: 收到的脚本信息.
- (void)userContentController:(WKUserContentController *)userContentController didReceiveScriptMessage:(WKScriptMessage *)message;

• WKUIDelegate：UI界面相关，原生控件支持，三种提示框：输入、确认、警告。首先将web提示框拦截然后再做处理。

/// 创建一个新的WebView
- (WKWebView *)webView:(WKWebView *)webView createWebViewWithConfiguration:(WKWebViewConfiguration *)configuration 
forNavigationAction:(WKNavigationAction *)navigationAction windowFeatures:(WKWindowFeatures *)windowFeatures;
/// 输入框
- (void)webView:(WKWebView *)webView runJavaScriptTextInputPanelWithPrompt:(NSString *)prompt 
defaultText:(nullable NSString *)defaultText initiatedByFrame:(WKFrameInfo *)frame 
completionHandler:(void (^)(NSString * __nullable result))completionHandler;
/// 确认框
- (void)webView:(WKWebView *)webView runJavaScriptConfirmPanelWithMessage:(NSString *)message initiatedByFrame:(WKFrameInfo *)frame 
completionHandler:(void (^)(BOOL result))completionHandler;
/// 警告框
- (void)webView:(WKWebView *)webView runJavaScriptAlertPanelWithMessage:(NSString *)message initiatedByFrame:(WKFrameInfo *)frame
 completionHandler:(void (^)(void))completionHandler;

四、示例代码

• 代码可以实现一般网络显示，加载本地文件(pdf、word、txt、图片等等)
• 搜索框搜索界面，搜索框输入file://则加载本地文件，http://则加载网络内容，如果两者都不是则搜索输入的关键字。
• 下部网络导航，后退、前进、刷新、用Safari打开链接四个按钮

/// 控件高度
#define kSearchBarH  44
#define kBottomViewH 44

/// 屏幕大小尺寸
#define kScreenWidth  [UIScreen mainScreen].bounds.size.width
#define kScreenHeight [UIScreen mainScreen].bounds.size.height

#import "ViewController.h"
#import <WebKit/WebKit.h>


@interface ViewController () <UISearchBarDelegate, WKNavigationDelegate>

@property (nonatomic, strong) UISearchBar *searchBar;
/// 网页控制导航栏
@property (weak, nonatomic) UIView *bottomView;

@property (nonatomic, strong) WKWebView *wkWebView;

@property (weak, nonatomic) UIButton *backBtn;
@property (weak, nonatomic) UIButton *forwardBtn;
@property (weak, nonatomic) UIButton *reloadBtn;
@property (weak, nonatomic) UIButton *browserBtn;

@property (weak, nonatomic) NSString *baseURLString;

@end

@implementation ViewController

- (void)viewDidLoad {
    [super viewDidLoad];
//    [self simpleExampleTest];

    [self addSubViews];
    [self refreshBottomButtonState];

    [self.wkWebView loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:@"http://www.cnblogs.com/mddblog/"]]];

}
- (void)simpleExampleTest {
    // 1.创建webview，并设置大小，"20"为状态栏高度
    WKWebView *webView = [[WKWebView alloc] initWithFrame:CGRectMake(0, 20, self.view.frame.size.width, 
self.view.frame.size.height - 20)];
    // 2.创建请求
    NSMutableURLRequest *request =[NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http://www.cnblogs.com/mddblog/"]];
//    // 3.加载网页
    [webView loadRequest:request];
//    [webView loadFileURL:[NSURL fileURLWithPath:@"/Users/userName/Desktop/bigIcon.png"] 
allowingReadAccessToURL:[NSURL fileURLWithPath:@"/Users/userName/Desktop/bigIcon.png"]];
    // 最后将webView添加到界面
    [self.view addSubview:webView];
}
/// 模拟器加载mac本地文件
- (void)loadLocalFile {
    // 1.创建webview，并设置大小，"20"为状态栏高度
    WKWebView *webView = [[WKWebView alloc] initWithFrame:CGRectMake(0, 20, self.view.frame.size.width, 
self.view.frame.size.height - 20)];
    // 2.创建url  userName：电脑用户名
    NSURL *url = [NSURL fileURLWithPath:@"/Users/userName/Desktop/bigIcon.png"];
    // 3.加载文件
    [webView loadFileURL:url allowingReadAccessToURL:url];
    // 最后将webView添加到界面
    [self.view addSubview:webView];
}
- (void)addSubViews {
    [self addBottomViewButtons];

    [self.view addSubview:self.searchBar];

    [self.view addSubview:self.wkWebView];
}

- (void)addBottomViewButtons {
    // 记录按钮个数
    int count = 0;
    // 添加按钮
    UIButton *button = [UIButton buttonWithType:UIButtonTypeCustom];
    [button setTitle:@"后退" forState:UIControlStateNormal];
    [button setTitleColor:[UIColor colorWithRed:249 / 255.0 green:102 / 255.0 blue:129 / 255.0 alpha:1.0] 
forState:UIControlStateNormal];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateHighlighted];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateDisabled];
    [button.titleLabel setFont:[UIFont systemFontOfSize:15]];
    button.tag = ++count;    // 标记按钮
    [button addTarget:self action:@selector(onBottomButtonsClicled:) forControlEvents:UIControlEventTouchUpInside];
    [self.bottomView addSubview:button];
    self.backBtn = button;

    button = [UIButton buttonWithType:UIButtonTypeCustom];
    [button setTitle:@"前进" forState:UIControlStateNormal];
    [button setTitleColor:[UIColor colorWithRed:249 / 255.0 green:102 / 255.0 blue:129 / 255.0 alpha:1.0] 
forState:UIControlStateNormal];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateHighlighted];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateDisabled];
    [button.titleLabel setFont:[UIFont systemFontOfSize:15]];
    button.tag = ++count;
    [button addTarget:self action:@selector(onBottomButtonsClicled:) forControlEvents:UIControlEventTouchUpInside];
    [self.bottomView addSubview:button];
    self.forwardBtn = button;

    button = [UIButton buttonWithType:UIButtonTypeCustom];
    [button setTitle:@"重新加载" forState:UIControlStateNormal];
    [button setTitleColor:[UIColor colorWithRed:249 / 255.0 green:102 / 255.0 blue:129 / 255.0 alpha:1.0] 
forState:UIControlStateNormal];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateHighlighted];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateDisabled];
    [button.titleLabel setFont:[UIFont systemFontOfSize:15]];
    button.tag = ++count;
    [button addTarget:self action:@selector(onBottomButtonsClicled:) forControlEvents:UIControlEventTouchUpInside];
    [self.bottomView addSubview:button];
    self.reloadBtn = button;

    button = [UIButton buttonWithType:UIButtonTypeCustom];
    [button setTitle:@"Safari" forState:UIControlStateNormal];
    [button setTitleColor:[UIColor colorWithRed:249 / 255.0 green:102 / 255.0 blue:129 / 255.0 alpha:1.0] 
forState:UIControlStateNormal];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateHighlighted];
    [button setTitleColor:[UIColor lightGrayColor] forState:UIControlStateDisabled];
    [button.titleLabel setFont:[UIFont systemFontOfSize:15]];
    button.tag = ++count;
    [button addTarget:self action:@selector(onBottomButtonsClicled:) forControlEvents:UIControlEventTouchUpInside];
    [self.bottomView addSubview:button];
    self.browserBtn = button;
    // 统一设置frame
    [self setupBottomViewLayout];
}
- (void)setupBottomViewLayout
{
    int count = 4;
    CGFloat btnW = 80;
    CGFloat btnH = 30;

    CGFloat btnY = (self.bottomView.bounds.size.height - btnH) / 2;
    // 按钮间间隙
    CGFloat margin = (self.bottomView.bounds.size.width - btnW * count) / count;

    CGFloat btnX = margin * 0.5;
    self.backBtn.frame = CGRectMake(btnX, btnY, btnW, btnH);

    btnX = self.backBtn.frame.origin.x + btnW + margin;
    self.forwardBtn.frame = CGRectMake(btnX, btnY, btnW, btnH);

    btnX = self.forwardBtn.frame.origin.x + btnW + margin;
    self.reloadBtn.frame = CGRectMake(btnX, btnY, btnW, btnH);

    btnX = self.reloadBtn.frame.origin.x + btnW + margin;
    self.browserBtn.frame = CGRectMake(btnX, btnY, btnW, btnH);
}
/// 刷新按钮是否允许点击
- (void)refreshBottomButtonState {
    if ([self.wkWebView canGoBack]) {
        self.backBtn.enabled = YES;
    } else {
        self.backBtn.enabled = NO;
    }

    if ([self.wkWebView canGoForward]) {
        self.forwardBtn.enabled = YES;
    } else {
        self.forwardBtn.enabled = NO;
    }
}
/// 按钮点击事件
- (void)onBottomButtonsClicled:(UIButton *)sender {
    switch (sender.tag) {
        case 1:
        {
            [self.wkWebView goBack];
            [self refreshBottomButtonState];
        }
            break;
        case 2:
        {
            [self.wkWebView goForward];
            [self refreshBottomButtonState];
        }
            break;
        case 3:
            [self.wkWebView reload];
            break;
        case 4:
            [[UIApplication sharedApplication] openURL:self.wkWebView.URL];
            break;
        default:
            break;
    }
}

#pragma mark - WKWebView WKNavigationDelegate 相关
/// 是否允许加载网页 在发送请求之前，决定是否跳转
- (void)webView:(WKWebView *)webView decidePolicyForNavigationAction:(WKNavigationAction *)navigationAction 
decisionHandler:(void (^)(WKNavigationActionPolicy))decisionHandler {

    NSString *urlString = [[navigationAction.request URL] absoluteString];

    urlString = [urlString stringByRemovingPercentEncoding];
    //    NSLog(@"urlString=%@",urlString);
    // 用://截取字符串
    NSArray *urlComps = [urlString componentsSeparatedByString:@"://"];
    if ([urlComps count]) {
        // 获取协议头
        NSString *protocolHead = [urlComps objectAtIndex:0];
        NSLog(@"protocolHead=%@",protocolHead);
    }
    decisionHandler(WKNavigationActionPolicyAllow);
}


#pragma mark - searchBar代理方法
/// 点击搜索按钮
- (void)searchBarSearchButtonClicked:(UISearchBar *)searchBar {
    // 创建url
    NSURL *url = nil;
    NSString *urlStr = searchBar.text;

    // 如果file://则为打开bundle本地文件，http则为网站，否则只是一般搜索关键字
    if([urlStr hasPrefix:@"file://"]){
        NSRange range = [urlStr rangeOfString:@"file://"];
        NSString *fileName = [urlStr substringFromIndex:range.length];
        url = [[NSBundle mainBundle] URLForResource:fileName withExtension:nil];
        // 如果是模拟器加载电脑上的文件，则用下面的代码
//        url = [NSURL fileURLWithPath:fileName];
    }else if(urlStr.length>0){
        if ([urlStr hasPrefix:@"http://"]) {
            url=[NSURL URLWithString:urlStr];
        } else {
            urlStr=[NSString stringWithFormat:@"http://www.baidu.com/s?wd=%@",urlStr];
        }
        urlStr = [urlStr stringByAddingPercentEncodingWithAllowedCharacters:[NSCharacterSet URLQueryAllowedCharacterSet]];
        url=[NSURL URLWithString:urlStr];

    }
    NSURLRequest *request=[NSURLRequest requestWithURL:url];

    // 加载请求页面
    [self.wkWebView loadRequest:request];
}
#pragma mark - 懒加载
- (UIView *)bottomView {
    if (_bottomView == nil) {
        UIView *view = [[UIView alloc] initWithFrame:CGRectMake(0, kScreenHeight - kBottomViewH, kScreenWidth, kBottomViewH)];
        view.backgroundColor = [UIColor colorWithRed:230/255.0 green:230/255.0 blue:230/255.0 alpha:1];
        [self.view addSubview:view];
        _bottomView = view;
    }
    return _bottomView;
}
- (UISearchBar *)searchBar {
    if (_searchBar == nil) {
        UISearchBar *searchBar = [[UISearchBar alloc] initWithFrame:CGRectMake(0, 20, kScreenWidth, kSearchBarH)];
        searchBar.delegate = self;
        searchBar.text = @"http://www.cnblogs.com/mddblog/";
        _searchBar = searchBar;

    }
    return _searchBar;
}

- (WKWebView *)wkWebView {
    if (_wkWebView == nil) {
        WKWebView *webView = [[WKWebView alloc] initWithFrame:CGRectMake(0, 20 + kSearchBarH, kScreenWidth, 
kScreenHeight - 20 - kSearchBarH - kBottomViewH)];
        webView.navigationDelegate = self;
//                webView.scrollView.scrollEnabled = NO;

        //        webView.backgroundColor = [UIColor colorWithPatternImage:self.image];
        // 允许左右划手势导航，默认允许
        webView.allowsBackForwardNavigationGestures = YES;
        _wkWebView = webView;
    }

    return _wkWebView;
}


@end

五、UIWebView 和 WKWebView的性能分析

iOS 8 推出 WKWebView 以及相关特性，告诉开发者提高多么多么大的性能，实测告诉你WKWebView的性能有多好！

为了验证，我在项目中的分别 使用UIWebView 和 WKWebView 测试，来回加载十多个网页 产生的内存状况如下：

对比发现 WKWebview 这货 在persistent 常驻内存 使用得少多了，想想看，一个app去哪儿省下几十M的内存，再加上用户量分布
iOS 9 60%
iOS 8 30%
iOS 7 6％左右
所以我建议能换WKWebview 就换吧，省下一大块内存减少不必要的异常bug。

iOSH5性能监控技术角度分析

性能数据了解

分析移动端H5性能数据，首先我们说说是哪些性能数据。

• 白屏时间，白屏时间无论安卓还是iOS在加载网页的时候都会存在的问题，也是目前无法解决的；
• 页面耗时，页面耗时指的是开始加载这个网页到整个页面load完成即渲染完成的时间；
• 加载链接的一些性能数据，重定向时间，DNS解析时间，TCP链接时间，request请求时间，response响应时间，dom节点解析时间，page渲染时间，同时我们还需要抓取资源时序数据，

什么是资源时序数据呢？每个网页是有很多个资源组成的，有.js、.png、.css、.script等等，我们就需要将这些每个资源链接的耗时拿到，是什么类型的资源，完整链接；对于客户来说有了这些还不够，还需要JS错误，页面的ajax请求。JS错误获取的当然是堆栈信息和错误类型。ajax请求一般是获取三个时间，响应时间，ajax下载时间，ajax回调时间。

上面分析的是能够获取到移动端H5的性能数据，这些数据怎么得到就是接下来要讲的了。数据获取是需要js来做的，都知道移动端是通过webView来加载网页的，js里面能通过performance这个接口来从webView内部api获取上面的那些数据，js获取的数据然后发给OC；那JS怎么样才能拿到这些数据呢，这就是最关键的，OC代码如何写才能让JS获取数据。

代码编写

有两种方法可以得到数据,先介绍用NSURLProtocol这个类获取数据。

iOS的UIWebView加载网页的时候会走进NSURLProtocol这个类,所以我们就需要在这个类里面作文章了,我们先用UIWebView加载一个链接，例如百度等等,然后创建一个继承NSURLProtocol的类。

继承NSURLProtocol

NSURLProtocol里面有很多方法，就不一一介绍了，有一个startLoading的方法,我们在这个方法里面用NSURLConnection发送一个请求,设置代理,请求的request就是加载网页的request，因为NSURLProtocol有一个NSURLRequest的属性。

- (instancetype)initWithRequest:(NSURLRequest*)request delegate:(id)delegate startImmediately:(BOOL)startImmediately

这个就是请求的方法。

发送请求

- (void)connection:(NSURLConnection *)connection didReceiveData:(NSData *)data

通过NSURLConnection设置代理,就需要写出代理方法，在其中一个代理方法里面能获得网页的代码，这就是我们最关键的地方，就是上面这个方法，将data用utf-8转码就会得到代码。

插入js代码的方法

得到网页的代码有什么用呢？熟悉网页端代码的都知道，网页端的代码都是由很多标签组成,我们先找到<head>这个标签，在下面插入一个<script>标签，里面放入js代码,这个js代码就是用来获取上面介绍的性能数据。

- (void)URLProtocol:(NSURLProtocol *)protocol didLoadData:(NSData *)data;

上面会用到很多这个方法,为什么要用这个呢，因为你注入了新的代码，你需要将这个新的网页代码用这个方法加载一下,不然网页会加载不出来的。

最后只需要将MonitorURLProtocol在appDelegate里面注册一下就可以了。

注册创建的类

以上是通过NSURLProtocol这个类注入获取数据的代码,将JS代码注入后就需要JS将数据发送给我们,可以通过交互这些方式，接下来我就介绍一种直白的交互,大多数的交互也是这么做的，只不过封装了,考虑的情况更多，我就只是根据实际情况来做了。

OC与JS交互获取数据

交互都会有一个标识，OC传一个标识给JS，JS通过标识判断，发送给你想要的数据。我首先是通过运行时动态加载的方法将加载链接的三个方法给hook，进入同一个我定义的方法，然后在这个方法里面传标识给JS。

hook

数据获取

将标识和block作为键值对存起来，然后将JS将数据用url的形式发过来，我们取出来，匹配一下对应相应的标识,然后用block回调相应的数据,相应的代码这里就不贴了,最后我会给github上代码的链接。接受url就是用UIWebView的代理方法。

- (BOOL)webView:(UIWebView *)webView shouldStartLoadWithRequest:(NSURLRequest *)request navigationType:(UIWebViewNavigationType)navigationType;

{

  [WebViewTracker webView:webView withUrl:request.URL];

  return YES;

}

我们还可以在didFinishLoad里面手动调用JS代码来获取获取数据,和NSURLProtocol结合起来用,各有各的优缺点,一个是在顶部注入代码,一个是在尾部调用代码，都是会丢失一部分数据，所以最好的办法就是结合起来用。

Android EventBus 3.0 用法及其原理详解

现在的项目中要用到应用程序内各组件间、组件与后台线程间的通信，2个方案可以实现这个功能，一个是利用回调。另一个是用EventBus。因为回调太繁琐，所以决定用EventBus。因为以前用过EventBus，所以直接去github看看有什么新功能，可一看，竟然3.0了，并且和2.0+的用法有很大的不同，所以就研究了下他的源码，记录下来，让大家参考参考，有什么不对的地方，欢迎大家指出。

我现在要介绍的是EventBus 3.0，你可以没有用过EventBus，因为我介绍的会很详细。

EventBus 3.0的使用

首先你要为你的app添加依赖库：
compile 'de.greenrobot:eventbus:3.0.0'

定义一个事件类型:里面的数据根据需求来，也可以是一个空的类。

`public class MainMessage {
    public String msg;
    public MainMessage(String msg) {
    this.msg = msg;
    }
}`

注册：注意，不要忘了在onDestroy里面的代码哦！

`@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);
    //注册
    EventBus.getDefault().register(this);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    //反注册
    EventBus.getDefault().unregister(this);
}`

订阅：在注册了的页面中,声明处理事件的方法

`//主线程中执行
@Subscribe(threadMode = ThreadMode.MAIN,priority = 100)
public void onMainEventBus(MainMessage msg) {
    }
}`

1) ThreadMode总共四个：

NAIN UI主线程

BACKGROUND 后台线程

POSTING 和发布者处在同一个线程

ASYNC 异步线程

2) priority:事件的优先级类似广播的优先级，优先级越高优先获得消息.
3）Sticky事件的使用 ：之前说的使用方法, 都是需要先注册(register), 再post,才能接受到事件; 如果你使用postSticky发送事件, 那么可以不需要先注册, 也能接受到事件。

首先,你可能需要声明一个方法

`   //注意,和之前的方法一样,只是多了一个 sticky = true 的属性.
    @Subscribe(threadMode = ThreadMode.MainThread, sticky = true)
    public void onEvent(MainMessage event){
    }`

其次, 你可以在没有register的情况下:(发送事件)

`EventBus.getDefault().postSticky(new MainMessage("With Sticky"));`

之后, 再注册,这样就可以收到刚刚发送的事件了:

`EventBus.getDefault().register(this);//注册之后,马上就能收到刚刚postSticky发送的事件`

发布：在任意地方,调用发送事件
EventBus.getDefault().post(new MainMessage(msg));

现在就ok了，如果你只是用的话就ok了，但是，如果不知道它的原理，我老感觉心里不舒服，用着不放心，接下来就介绍他的原理

首先，我们看看注册register()方法的实现

3.0的只提供了一个register()方法

` public void register(Object subscriber) {
    //首先获得订阅者的class对象
    Class<?> subscriberClass = subscriber.getClass();
    //通过subscriberMethodFinder来找到订阅者订阅了哪些事件.返回一个SubscriberMethod对象的List,SubscriberMethod
    //里包含了这个方法的Method对象,以及将来响应订阅是在哪个线程的ThreadMode,以及订阅的事件类型eventType,以及订阅的优
    //先级priority,以及是否接收粘性sticky事件的boolean值.
    List<SubscriberMethod> subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            //订阅
            subscribe(subscriber, subscriberMethod);
        }
    }
}`

这里就是设计模式里我们常用的单例模式了,目的是为了保证getDefault()得到的都是同一个实例。如果不存在实例,就调用了EventBus的构造方法:

` private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

public EventBus() {
    this(DEFAULT_BUILDER);
}

EventBus(EventBusBuilder builder) {
    //key:订阅的事件,value:订阅这个事件的所有订阅者集合
    //private final Map<Class<?>, CopyOnWriteArrayList<Subscription>> subscriptionsByEventType;
    subscriptionsByEventType = new HashMap<>();
    //key:订阅者对象,value:这个订阅者订阅的事件集合
    //private final Map<Object, List<Class<?>>> typesBySubscriber;
    typesBySubscriber = new HashMap<>();
    //粘性事件 key:粘性事件的class对象, value:事件对象
    //private final Map<Class<?>, Object> stickyEvents;
    stickyEvents = new ConcurrentHashMap<>();
    //事件主线程处理
    mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
    //事件 Background 处理
    backgroundPoster = new BackgroundPoster(this);
    //事件异步线程处理
    asyncPoster = new AsyncPoster(this);
    indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
    //订阅者响应函数信息存储和查找类
    subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
            builder.strictMethodVerification, builder.ignoreGeneratedIndex);
    logSubscriberExceptions = builder.logSubscriberExceptions;
    logNoSubscriberMessages = builder.logNoSubscriberMessages;
    sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
    sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
    throwSubscriberException = builder.throwSubscriberException;
    //是否支持事件继承
    eventInheritance = builder.eventInheritance;
    executorService = builder.executorService;
}`

可以看出是通过初始化了一个EventBusBuilder()对象来分别初始化EventBus的一些配置,当我们在写一个需要自定义配置的框架的时候,这种实现方法非常普遍,将配置解耦出去,使我们的代码结构更清晰.

我把每行的代码都写了注释，可以看到register()方法很简洁,我们可以看出通过subscriberMethodFinder.findSubscriberMethods(subscriberClass)方法就能返回一个SubscriberMethod的对象,而SubscriberMethod里包含了所有我们需要的接下来执行subscribe()的信息.所以我们先去看看findSubscriberMethods()是怎么实现的,然后我们再去关注subscribe()。

SubscriberMethodFinder的实现

一句话来描述SubscriberMethodFinder类就是用来查找和缓存订阅者响应函数的信息的类。下面我们就来看findSubscriberMethods()到底是如何实现的:

`   List<SubscriberMethod> findSubscriberMethods(Class<?> subscriberClass) {
    //先从METHOD_CACHE取看是否有缓存,key:保存订阅类的类名,value:保存类中订阅的方法数据,
    List<SubscriberMethod> subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
        return subscriberMethods;
    }
    //是否忽略注解器生成的MyEventBusIndex类
    if (ignoreGeneratedIndex) {
        //利用反射来读取订阅类中的订阅方法信息
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        //从注解器生成的MyEventBusIndex类中获得订阅类的订阅方法信息
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    if (subscriberMethods.isEmpty()) {
        throw new EventBusException("Subscriber " + subscriberClass
                + " and its super classes have no public methods with the @Subscribe annotation");
    } else {
        //保存进METHOD_CACHE缓存
        METHOD_CACHE.put(subscriberClass, subscriberMethods);
        return subscriberMethods;
    }
}`

注释很详细我们就不在多说,由于篇幅原因我们就不在分析findUsingInfo()方法,其无非就是通过查找我们上面所说的MyEventBusIndex类中的信息,来转换成List从而获得订阅类的相关订阅函数的各种信息.有兴趣的可以自己研究看看,下面我们就来看findUsingReflection()方法是如何实现的:

`  private List<SubscriberMethod> findUsingReflection(Class<?> subscriberClass) {
    //FindState 用来做订阅方法的校验和保存
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        //通过反射来获得订阅方法信息
        findUsingReflectionInSingleClass(findState);
        //查找父类的订阅方法
        findState.moveToSuperclass();
    }
    //获取findState中的SubscriberMethod(也就是订阅方法List)并返回
    return getMethodsAndRelease(findState);
}`

这里通过FindState类来做订阅方法的校验和保存,并通过FIND_STATE_POOL静态数组来保存FindState对象,可以使FindState复用,避免重复创建过多的对象.最终是通过findUsingReflectionInSingleClass()来具体获得相关订阅方法的信息的:

`private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    //通过反射得到方法数组
    try {
        // This is faster than getMethods, especially when subscribers are fat classes like Activities
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
        // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
        methods = findState.clazz.getMethods();
        findState.skipSuperClasses = true;
    }
    //遍历Method
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
            Class<?>[] parameterTypes = method.getParameterTypes();
            //保证必须只有一个事件参数
            if (parameterTypes.length == 1) {
                //得到注解
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                if (subscribeAnnotation != null) {
                    Class<?> eventType = parameterTypes[0];
                    //校验是否添加该方法
                    if (findState.checkAdd(method, eventType)) {
                        ThreadMode threadMode = subscribeAnnotation.threadMode();
                        //实例化SubscriberMethod对象并添加
                        findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                    }
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException("@Subscribe method " + methodName +
                        "must have exactly 1 parameter but has " + parameterTypes.length);
            }
        } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
            String methodName = method.getDeclaringClass().getName() + "." + method.getName();
            throw new EventBusException(methodName +
                    " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
        }
    }
}`

到这里，我们订阅类的所有SubscriberMethod都已经被保存了,最后再通过getMethodsAndRelease()返回List至此,所有关于如何获得订阅类的订阅方法信息即:SubscriberMethod对象就已经完全分析完了.

post()方法原理分析

` public void post(Object event) {
    //得到当前线程的Posting状态.
    PostingThreadState postingState = currentPostingThreadState.get();
    //获取当前线程的事件队列
    List<Object> eventQueue = postingState.eventQueue;
    eventQueue.add(event);

    if (!postingState.isPosting) {
        postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
        postingState.isPosting = true;
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        try {
            //一直发送
            while (!eventQueue.isEmpty()) {
                //发送单个事件
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
            postingState.isPosting = false;
            postingState.isMainThread = false;
        }
    }
}`

首先是通过currentPostingThreadState.get()方法来得到当前线程PostingThreadState的对象。
currentPostingThreadState的实现是一个包含了PostingThreadState的ThreadLocal对象,关于ThreadLocal
张涛的这篇文章解释的很好:ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，
而这段数据是不会与其他线程共享的。其内部原理是通过生成一个它包裹的泛型对象的数组，在不同的线程会有不同的数组索引值，通过这样就可以做到每个线程通过get() 方法获取的时候，取到的只能是自己线程所对应的数据。 所以这里取到的就是每个线程的PostingThreadState状态.接下来我们来看postSingleEvent()方法:

`private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
    Class<?> eventClass = event.getClass();
    boolean subscriptionFound = false;
    //是否触发订阅了该事件(eventClass)的父类,以及接口的类的响应方法.
    if (eventInheritance) {
        //查找eventClass类所有的父类以及接口
        List<Class<?>> eventTypes = lookupAllEventTypes(eventClass);
        int countTypes = eventTypes.size();
        //循环postSingleEventForEventType
        for (int h = 0; h < countTypes; h++) {
            Class<?> clazz = eventTypes.get(h);
            //只要右边有一个为true,subscriptionFound就为true
            subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
        }
    } else {
        //post单个
        subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
    }
    //如果没发现
    if (!subscriptionFound) {
        if (logNoSubscriberMessages) {
            Log.d(TAG, "No subscribers registered for event " + eventClass);
        }
        if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                eventClass != SubscriberExceptionEvent.class) {
            //发送一个NoSubscriberEvent事件,如果我们需要处理这种状态,接收这个事件就可以了
            post(new NoSubscriberEvent(this, event));
        }
    }
}`

现在发现是在postSingleEventForEventType()方法里去进行事件的分发,代码如下:

` private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class<?> eventClass) {
    CopyOnWriteArrayList<Subscription> subscriptions;
    //获取订阅了这个事件的Subscription列表.
    synchronized (this) {
        subscriptions = subscriptionsByEventType.get(eventClass);
    }
    if (subscriptions != null && !subscriptions.isEmpty()) {
        for (Subscription subscription : subscriptions) {
            postingState.event = event;
            postingState.subscription = subscription;
            //是否被中断
            boolean aborted = false;
            try {
                //分发给订阅者
                postToSubscription(subscription, event, postingState.isMainThread);
                aborted = postingState.canceled;
            } finally {
                postingState.event = null;
                postingState.subscription = null;
                postingState.canceled = false;
            }
            if (aborted) {
                break;
            }
        }
        return true;
    }
    return false;
}

private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    switch (subscription.subscriberMethod.threadMode) {
        case POSTING:
            invokeSubscriber(subscription, event);
            break;
        case MAIN:
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        case BACKGROUND:
            if (isMainThread) {
                backgroundPoster.enqueue(subscription, event);
            } else {
                invokeSubscriber(subscription, event);
            }
            break;
        case ASYNC:
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}`

总结上面的代码就是,首先从subscriptionsByEventType里获得所有订阅了这个事件的Subscription列表,然后在通过postToSubscription()方法来分发事件,在postToSubscription()通过不同的threadMode在不同的线程里invoke()订阅者的方法。

解除注册：unregister()方法分析

` public synchronized void unregister(Object subscriber) {
    //通过typesBySubscriber来取出这个subscriber订阅者订阅的事件类型,
    List<Class<?>> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        //分别解除每个订阅了的事件类型
        for (Class<?> eventType : subscribedTypes) {
            unsubscribeByEventType(subscriber, eventType);
        }
        //从typesBySubscriber移除subscriber
        typesBySubscriber.remove(subscriber);
    } else {
        Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}`

然后是unsubscribeByEventType()方法的实现:

` private void unsubscribeByEventType(Object subscriber, Class<?> eventType) {
    //subscriptionsByEventType里拿出这个事件类型的订阅者列表.
    List<Subscription> subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions != null) {
        int size = subscriptions.size();
        //取消订阅
        for (int i = 0; i < size; i++) {
            Subscription subscription = subscriptions.get(i);
            if (subscription.subscriber == subscriber) {
                subscription.active = false;
                subscriptions.remove(i);
                i--;
                size--;
            }
        }
    }
}`

可以看出是从typesBySubscriber和subscriptions里分别移除订阅者以及相关信息.

现在EventBus3.0 的大概解析已经完了，我们知道了原理就可以放心大胆的用了

现在额外的说一下EventBus processor，因为现在还是测试版，所以不推荐使用，知道就好。

EventBus processor使用： EventBus提供了一个EventBusAnnotationProcessor注解处理器来在编译期通过读取@Subscribe()注解并解析,
处理其中所包含的信息,然后生成java类来保存所有订阅者关于订阅的信息,这样就比在运行时使用反射来获得这些订阅者的
信息速度要快.

具体使用：在build.gradle中添加如下配置：

`provided 'de.greenrobot:eventbus-annotation-processor:3.0.0-beta1'`

使用前后，我测了一下，我的项目的代码大概能相差8-9毫秒，这个时间对我来说不是很多，所以我项目中就没有用。