注册
环信即时通讯云

环信即时通讯云

单聊、群聊、聊天室...
环信开发文档

环信开发文档

Demo体验

Demo体验

场景Demo,开箱即用
RTE开发者社区

RTE开发者社区

汇聚音视频领域技术干货,分享行业资讯
技术讨论区

技术讨论区

技术交流、答疑
资源下载

资源下载

收集了海量宝藏开发资源
iOS Library

iOS Library

不需要辛辛苦苦的去找轮子, 这里都有
Android Library

Android Library

不需要辛辛苦苦的去找轮子, 这里都有

Android面试:80%的面试官关于Glide都会问这几个问题!【建议收藏】

Glide的三级缓存有了解过么? 先来了解一下我们常说的图片三级缓存 一般是强引用,软引用和文件系统,Android系统中提供了LruCache,通过维护一个LinkedHashMap来保存我们需要的各种类型数据,例如我们这里需要的Bitmap。Lr...
继续阅读 »



Glide的三级缓存有了解过么?



  • 先来了解一下我们常说的图片三级缓存


一般是强引用,软引用和文件系统,Android系统中提供了LruCache,通过维护一个LinkedHashMap来保存我们需要的各种类型数据,例如我们这里需要的Bitmap。LruCache一般我们会设置为系统最大存储空间的八分之一,而它的机制就是我们常说的最近最少使用原则,如果Lru中的图片大小超过了默认大小,则会把最久使用的图片移除。


当图片被Lru移除时,我们需要手动将图片添加到软引用(SoftRefrence)中。需要维护一个软应用的集合在我们的项目中。



  • 简单概括一下常用的三级缓存的流程:


先去Lru中找,有则直接取。
没有,则去SoftRefrence中找,有则取,同时将图片放回Lru中。
没有的话去文件系统找,有则取,同时将图片添加到Lru中。
没有就走下载图片逻辑,保存到文件系统中,并放到Lru中。

下面介绍一下Glide的缓存结构:


Glide缓存严格意义上说只有内存缓存和磁盘缓存,内存缓存中又分为Lru和弱引用缓存。


所以Glide的三级缓存可以分为:Lru缓存,弱引用缓存,磁盘缓存。


下面我们看一下Glide的读取顺序,这里有一点不同,我用的是Glide4.8版本,跟之前版本的写入顺序稍有不同。


截取部分源码:

@NonNull
Glide build(@NonNull Context context) {

if (memoryCache == null) {
memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
}

if (engine == null) {
engine =
new Engine(
memoryCache,
diskCacheFactory,
diskCacheExecutor,
sourceExecutor,
GlideExecutor.newUnlimitedSourceExecutor(),
GlideExecutor.newAnimationExecutor(),
isActiveResourceRetentionAllowed);
}


  • memoryCache就是Glide使用的内存缓存,LruResourceCache类继承了LruCache,这部分可以自行查看一下源码。


通过上面可以看到,GLide#build()方法中实例化memoryCache作为Glide的内存缓存,并将其传给Engine作为构造器的入参。



  • Engine.class 截取部分源码


{
//生成缓存key
EngineKey key = keyFactory.buildKey(model, signature, width, height, transformations,
resourceClass, transcodeClass, options);
//从弱应用中读取缓存
EngineResource active = loadFromActiveResources(key, isMemoryCacheable);
if (active != null) {
cb.onResourceReady(active, DataSource.MEMORY_CACHE);
if (VERBOSE_IS_LOGGABLE) {
logWithTimeAndKey("Loaded resource from active resources", startTime, key);
}
return null;
}
//从LruCache中读取缓存
EngineResource cached = loadFromCache(key, isMemoryCacheable);
if (cached != null) {
cb.onResourceReady(cached, DataSource.MEMORY_CACHE);
if (VERBOSE_IS_LOGGABLE) {
logWithTimeAndKey("Loaded resource from cache", startTime, key);
}
return null;
}
EngineJob engineJob =
engineJobFactory.build(
key,
isMemoryCacheable,
useUnlimitedSourceExecutorPool,
useAnimationPool,
onlyRetrieveFromCache);
jobs.put(key, engineJob);

engineJob.addCallback(cb);
//开启线程池,加载图片
engineJob.start(decodeJob);
}

从上可知,Glide加载过程中使用loadFromActiveResources方法和loadFromCache方法来获取内存缓存的。


大致总结一下: 首先从弱引用读取缓存,没有的话通过Lru读取,有则取,并且加到弱引用中,如果没有会开启EngineJob进行后面的图片加载逻辑。


下面直接看之后的缓存部分代码:



  • Engine#onEngineJobComplete()


public void onEngineJobComplete(EngineJob engineJob, Key key, EngineResource resource) {
Util.assertMainThread();
// A null resource indicates that the load failed, usually due to an exception.
if (resource != null) {
resource.setResourceListener(key, this);

if (resource.isCacheable()) {
activeResources.activate(key, resource);
}
}

jobs.removeIfCurrent(key, engineJob);
}
void activate(Key key, EngineResource resource) {
ResourceWeakReference toPut =
new ResourceWeakReference(
key,
resource,
getReferenceQueue(),
isActiveResourceRetentionAllowed);

ResourceWeakReference removed = activeEngineResources.put(key, toPut);
if (removed != null) {
removed.reset();
}
}

这里可以看到activeResources.activate(key, resource)把EngineResource放到了弱引用中,至于lru的放置逻辑如下:



  • EngineResource#release()


void release() {
if (acquired <= 0) {
throw new IllegalStateException("Cannot release a recycled or not yet acquired resource");
}
if (!Looper.getMainLooper().equals(Looper.myLooper())) {
throw new IllegalThreadStateException("Must call release on the main thread");
}
if (--acquired == 0) {
listener.onResourceReleased(key, this);
}
}

当acquired变量大于0的时候,说明图片正在使用中,也就应该放到activeResources弱引用缓存当中。而经过release()之后,如果acquired变量等于0了,说明图片已经不再被使用了,那么此时会调用listener的onResourceReleased()方法来释放资源。



  • Engine#onResourceReleased()


@Override
public void onResourceReleased(Key cacheKey, EngineResource resource) {
Util.assertMainThread();
activeResources.deactivate(cacheKey);
if (resource.isCacheable()) {
cache.put(cacheKey, resource);
} else {
resourceRecycler.recycle(resource);
}
}

这里首先会将缓存图片从activeResources中移除,然后再将它put到LruResourceCache当中。这样也就实现了正在使用中的图片使用弱引用来进行缓存,不在使用中的图片使用LruCache来进行缓存的功能。


接下来就是Glide的磁盘缓存,磁盘缓存简单来说就是根据Key去DiskCache中取缓存,有兴趣可以自行看一下源码。


为什么选择Glide不选择其他的图片加载框架?



  • Glide和Picasso


前者要更加省内存,可以按需加载图片,默认为ARGB_565,后者为ARGB_8888。


前者支持Gif,后者并不支持。



  • Glide和Fresco


Fresco低版本有优势,占用部分native内存,但是高版本一样是java内存。


Fresco加载对图片大小有限制,Glide基本没有。


Fresco推荐使用SimpleDraweeView,涉及到布局文件,这就不得不考虑迁移的成本。


Fresco有很多native的实现,想改源码成本要大的多。


Glide提供对中TransFormation帮助处理图片,Fresco并没有。


Glide版本迭代相对较快。


Glide的几个显著的优点:



  • 生命周期的管理


GLide#with


  @NonNull
public static RequestManager with(@NonNull Context context) {
return getRetriever(context).get(context);
}

@NonNull
public static RequestManager with(@NonNull Activity activity) {
return getRetriever(activity).get(activity);
}

@NonNull
public static RequestManager with(@NonNull FragmentActivity activity) {
return getRetriever(activity).get(activity);
}

@NonNull
public static RequestManager with(@NonNull Fragment fragment) {
return getRetriever(fragment.getActivity()).get(fragment);
}

@Deprecated
@NonNull
public static RequestManager with(@NonNull android.app.Fragment fragment) {
return getRetriever(fragment.getActivity()).get(fragment);
}

可以看到有多个重载方法,主要对两类不同的Context进行不同的处理



  • Application Context 图片加载的生命周期和应用程序一样,肯定是我们不推荐的写法。

  • 其余Context,会像当前Activity创建一个隐藏的Fragment,绑定生命周期。


以Activity为例:


 @NonNull
public RequestManager get(@NonNull Activity activity) {
if (Util.isOnBackgroundThread()) {
return get(activity.getApplicationContext());
} else {
//判断是否是销毁状态
assertNotDestroyed(activity);
android.app.FragmentManager fm = activity.getFragmentManager();
//绑定生命周期
return fragmentGet(
activity, fm, /*parentHint=*/ null, isActivityVisible(activity));
}
}

具体看#fragmentGet()


@NonNull
private RequestManager fragmentGet(@NonNull Context context,
@NonNull android.app.FragmentManager fm,
@Nullable android.app.Fragment parentHint,
boolean isParentVisible) {
//这就是绑定的Fragment,RequestManagerFragment
RequestManagerFragment current = getRequestManagerFragment(fm, parentHint, isParentVisible);
RequestManager requestManager = current.getRequestManager();

return requestManager;
}

接着看RequestManagerFragment


public class RequestManagerFragment extends Fragment {
@Override
public void onStart() {
super.onStart();
lifecycle.onStart();
}
@Override
public void onStop() {
super.onStop();
lifecycle.onStop();
}

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

}

关联lifeCycle相应的方法。


简单来说就是通过#with()方法根据穿过来的不同的Context绑定生命周期。



  • Bitmap对象池


Glide提供了一个BitmapPool来保存Bitmap。 简单来说就是当需要加载一个bitmap的时候,会根据图片的参数去池子里找到一个合适的bitmap,如果没有就重新创建。BitMapPool同样是根据Lru算法来工作的。从而提高性能。



  • 高效缓存


缓存相关可以看上文描述,内存和磁盘,磁盘缓存也提供了几种缓存策略。



  1. NONE,表示不缓存任何内容

  2. SOURCE,表示只缓存原始图片

  3. RESULT,表示只缓存转换过后的图片(默认选项)

  4. ALL, 表示既缓存原始图片,也缓存转换过后的图片


文末


好了,今天的文章就到这里,感谢阅读,喜欢的话不要忘了三连。大家的支持和认可,是我分享的最大动力。


对文章有何见解,或者有何技术问题,都可以在评论区一起留言讨论,我会虔诚为你解答。


收起阅读 »

做了这么多年开发,TypedArray你该知道的东西

大家好,我是程序员双木L,后续会发专题类的文章,这是自定义控件的第一篇,之后也会陆续更新相关的文章,欢迎关注。 自定义属性在自定义控件过程中属于比较常见的操作,我们可以回想一下这样的场景:自定义view的过程中,我们需要在不同的情况下设置不同的文字大小,那么...
继续阅读 »




大家好,我是程序员双木L,后续会发专题类的文章,这是自定义控件的第一篇,之后也会陆续更新相关的文章,欢迎关注。


自定义属性在自定义控件过程中属于比较常见的操作,我们可以回想一下这样的场景:自定义view的过程中,我们需要在不同的情况下设置不同的文字大小,那么我们是不是就需要提供对外的方法来设置,这样就比较灵活操作。而我们自定义对外的方法,就是我们自定义的属性啦,那我们来分析一下其原理及作用。


下面我们根据例子来进行分析:


1、首先我们需要在res->values目录下新建attrs.xml文件,该文件就是用来声明属性名及其接受的数据格式的,如下:


<?xml version="1.0" encoding="utf-8"?>
<resources>
<attr name="view_int" format="integer" />
<attr name="view_str" format="string" />
<attr name="view_bool" format="boolean" />
<attr name="view_color" format="color" />
<attr name="view_ref" format="reference" />
<attr name="view_float" format="float" />
<attr name="view_dim" format="dimension" />
<attr name="view_frac" format="fraction" />

<attr name="view_enum">
<enum name="num_one" value="1" />
<enum name="num_two" value="2" />
<enum name="num_three" value="3" />
<enum name="num_four" value="4" />
</attr>

<attr name="view_flag">
<flag name="top" value="0x1" />
<flag name="left" value="0x2" />
<flag name="right" value="0x3" />
<flag name="bottom" value="0x4" />
</attr>

</resources>

attr名词解析:


name表示属性名,上面的属性名是我自己定义的。


format表示接受的输入格式,format格式集合如下:


color:颜色值;
boolean:布尔值;
dimension:尺寸值,注意,这里如果是dp那就会做像素转换;
float:浮点值;
integer:整型值;
string:字符串;
fraction:百分数;
enum:枚举值;
flag:是自己定义的,就是里面对应了自己的属性值;
reference:指向其它资源;
reference|color:颜色的资源文件;
reference|boolean:布尔值的资源文件.

2、自定义属性的使用,这里我们使用两种方式进行对比解析


最最最原始的使用方式


(1)、自定义文件如下:


public class TestAttrsView extends View {
private final String TAG = "TestAttrsView:";

public TestAttrsView(Context context) {
this(context, null);
}

public TestAttrsView(Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}

public TestAttrsView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);

//最原始使用方式
for (int i = 0; i < attrs.getAttributeCount(); i++) {
Log.i(TAG, "name:" + attrs.getAttributeName(i) + " value:" + attrs.getAttributeValue(i));
}
}
}

我们可以在TestAttrsView方法的参数AttributeSet是个xml解析工具类,帮助我们从布局的xml里提取属性名和属性值。


(2)、在布局文件xml中的使用


<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">

<com.example.viewdemo.customView.TestAttrsView
android:layout_width="200dp"
android:layout_height="200dp"
app:view_bool="true"
app:view_color="#e5e5e5"
app:view_dim="10px"
app:view_float="5.0"
app:view_frac="100%"
app:view_int="10"
app:view_ref="@dimen/dp_15"
app:view_str="test attrs view" />

</FrameLayout>

这里使用自定义属性需要声明xml的命名空间,其中app是命名空间,用来加在自定义属性前面。


xmlns:app=“http://schemas.android.com/apk/res-auto”
声明xml命名空间,xmlns意思为“xml namespace”.冒号后面是给这个引用起的别名。
schemas是xml文档的两种约束文件其中的一种,规定了xml中有哪些元素(标签)、
元素有哪些属性及各元素的关系,当然从面向对象的角度理解schemas文件可以
认为它是被约束的xml文档的“类”或称为“模板”。


(3)、将属性名与属性值打印结果如下:


在这里插入图片描述


从打印结果我们可以看出,AttributeSet将布局文件xml下的属性全部打印出来了,细心的童鞋可能已经看出来:


xml文件:
app:view_ref="@dimen/dp_15"

打印结果:
name:view_ref value:@2131034213

这个属性我们设置的是一个整数尺寸,可最后打印出来的是资源编号。


那如果我们想要输出我们设置的整数尺寸,需要怎么操作呢?


这个时候就该我们这篇的主角出场了,使用TypedArray方式。



  • 使用TypedArray方式


(1)、这里我们需要将attrs.xml使用“declare-styleable”标签进行改造,如下:


<?xml version="1.0" encoding="utf-8"?>
<resources>

<declare-styleable name="TestStyleable">
<attr name="view_int" format="integer" />
<attr name="view_str" format="string" />
<attr name="view_bool" format="boolean" />
<attr name="view_color" format="color" />
<attr name="view_ref" format="reference" />
<attr name="view_float" format="float" />
<attr name="view_dim" format="dimension" />
<attr name="view_frac" format="fraction" />

<attr name="view_enum">
<enum name="num_one" value="1" />
<enum name="num_two" value="2" />
<enum name="num_three" value="3" />
<enum name="num_four" value="4" />
</attr>

<attr name="view_flag">
<flag name="top" value="0x1" />
<flag name="left" value="0x2" />
<flag name="right" value="0x3" />
<flag name="bottom" value="0x4" />
</attr>
</declare-styleable>

</resources>

从改造后的attrs文件可以看出,我们将属性声明归结到TestStyleable里面,也就意味着这些属性是属于TestStyleable下的。


(2)、属性的解析:


public class TestAttrsView extends View {
private final String TAG = "TestAttrsView:";

public TestAttrsView(Context context) {
this(context, null);
}

public TestAttrsView(Context context, @Nullable AttributeSet attrs) {
this(context, attrs, 0);
}

public TestAttrsView(Context context, @Nullable AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);

//最原始使用方式
/* for (int i = 0; i < attrs.getAttributeCount(); i++) {
Log.i(TAG, "name:" + attrs.getAttributeName(i) + " value:" + attrs.getAttributeValue(i));
}*/


//使用TypeArray方式
//R.styleable.TestStyleable 指的是想要解析的属性
TypedArray typedArray = context.obtainStyledAttributes(attrs, R.styleable.TestStyleable);

int integerView = typedArray.getInt(R.styleable.TestStyleable_view_int, 0);
Log.i(TAG, "name:view_int" + " value:" + integerView);

boolean aBooleanView = typedArray.getBoolean(R.styleable.TestStyleable_view_bool, false);
Log.i(TAG, "name:view_bool" + " value:" + aBooleanView);

int colorView = typedArray.getColor(R.styleable.TestStyleable_view_color, Color.WHITE);
Log.i(TAG, "name:view_color" + " value:" + colorView);

String stringView = typedArray.getString(R.styleable.TestStyleable_view_str);
Log.i(TAG, "name:view_str" + " value:" + stringView);

float refView = typedArray.getDimension(R.styleable.TestStyleable_view_ref, 0);
Log.i(TAG, "name:view_ref" + " value:" + refView);

float aFloatView = typedArray.getFloat(R.styleable.TestStyleable_view_float, 0);
Log.i(TAG, "name:view_float" + " value:" + aFloatView);

float dimensionView = typedArray.getDimension(R.styleable.TestStyleable_view_dim, 0);
Log.i(TAG, "name:view_dim" + " value:" + dimensionView);

float fractionView = typedArray.getFraction(R.styleable.TestStyleable_view_frac, 1, 1, 0);
Log.i(TAG, "name:view_frac" + " value:" + fractionView);

//typedArray存放在缓存池,使用完需要释放缓存池
typedArray.recycle();
}
}

这里我直接打印出解析结果,这里可以获取我们想要的自定义属性,而系统有的属性可以忽略。


(3)、运行结果如下


在这里插入图片描述


从解析的结果可以看出,尺寸的结果已经转换为实际值了:


xml文件:
app:view_ref="@dimen/dp_15"

打印结果:
name:view_ref value:41.25

这个时候有童鞋又问了,我设置的是15dp,为啥最后打印是41.25了呢?其实解析出来的值单位是px,所以这里输出的是转换后的值。


解析的过程中用到了这个方法:


context.obtainStyledAttributes(attrs, R.styleable.TestStyleable);

我们来看一下这个方法的源码:


   public final TypedArray obtainStyledAttributes(
@Nullable AttributeSet set, @NonNull @StyleableRes int[] attrs) {
return getTheme().obtainStyledAttributes(set, attrs, 0, 0);
}

源码中我们可以看到这个方法有两个参数:


AttributeSet set:表示当前xml声明的属性集合

int[] attrs:表示你想挑选的属性,你想得到哪些属性,你就可以将其写到这个int数组中


obtainStyledAttributes方法返回值类型为TypedArray。该类型记录了获取到的属性值集合,而通过数组下标索引即可找到对应的属性值。索引下标通过R.styleable.TestStyleable_xx获取,“xx"表示属性名,一般命名为"styleable名” + “_” + “属性名”。


而TypedArray提供了各种Api,如getInteger,getString,getDimension等方法来获取属性值,这些方法都需要传入对应属性名在obtainStyledAttributes中的int数组的位置索引,通过下标获取数组里属性值。


这个TypedArray的作用就是资源的映射作用,把自定义属性在xml设置值映射到class,这样怎么获取都很简单啦。


到这里就分析完啦!

收起阅读 »

想要进阶高级开发?快看画布的基础使用

【Android 自定义控件】2.画布的基础使用 1.设置画布的背景颜色 2.画圆形 基本语法 参数说明 3.画直线 单条直线: 基本语法 ...
继续阅读 »





1.设置画布的背景颜色


void  drawColor(int color)
void drawARGB(int a, int r, int g, int b)
void drawRGB(int r, int g, int b)

2.画圆形


//画笔
Paint paint=new Paint() ;
paint.setColor(OxFFFFOOOO );
paint.setStyle(Paint.Style.FILLANDSTROKE);
paint.setStrokeWidth(50);

//画布(画圆形)
canvas.drawCircle(l90, 200, 150, paint);

基本语法


void drawCircle (float cx, float cy, float radius, Paint paint)


参数说明


cx:圆心的x坐标。
cy:圆心的y坐标。
radius:圆的半径。
paint:绘制时所使用的画笔。


3.画直线


单条直线:


//画笔
Paint paint=new Paint() ;
paint.setColor(OxFFFFOOOO );
paint.setStrokeWidth(50);

//画布(画直线)
canvas.drawLine(100, 100, 200, 200, paint);

基本语法


void drawLine (float startX, float startY, float stopX, float stopY , Paint paint)


参数说明


startX:起始点 坐标。
startY:起始点 坐标
stopX:终点 坐标。
stopY:终点 坐标。
paint:绘制时所使用的画笔。


多条直线:


Paint paint = new Paint();
paint.setColor(color.RED);
paint.setStrokeWidth(5);

float []pts={10,10,100, 100, 200, 200,400,400};
canvas.drawLines(pts, 2,4,paint); //表示从pts 数组中索引为2的数字开始绘图,有4个数值参与绘图,也就是点(100,100)和(200,200),所以效果图就是这两个点的连线。

基本语法


void drawLines(float[] pts,Paint paint)
void drawLines(float [ ] pts,int offset, int count,Paint paint)


参数说明


pts:点的集合,pts的组织方式为{x1,y1,x2,y2,x3,y3,…}。
offset:集合中跳过的数值个数。注意不是点的个数!一个点有两个数值。
count:参与绘制的数值个数,指pts数组中数值的个数,而不是点的个数,因为一个点有两个数值。
paint:绘制时所使用的画笔。


4.画点


单个点


//画笔
Paint paint=new Paint() ;
paint.setColor(OxFFFFOOOO );
paint.setStrokeWidth(50);

//画布(画点)
canvas.drawPoint(100, 100, paint);

基本语法


void drawPoint(float x, float y, Paint paint)


参数说明


x:点的X坐标。
y:点的Y坐标。
paint:绘制时所使用的画笔。


多个点


Paint paint = new Paint();
paint.setColor(Color.RED);
paint.setStrokeWidth(25);

float[] pts = {10,10,100,100,200,200,400,400};
canvas.drawPoints(pts, 2, 4, paint); //4个点:(10,10)、(100,100)、(200,200)和(400,400),在 drawPoints()函数里跳过前两个数值,即第一个点的横、纵坐标,画出后面4个数值代表的点,即第二、三个点,第四个点没画。

基本语法


void drawPoints (float [] pts,Paint paint)
void drawPoints(float[ ] pts,int offset,int count,Paint paint)


参数说明


pts:点的合集,与上面的直线一致,样式为{x1,y1,x2,y2,x3,y3,…}。
offset:集合中跳过的数值个数。注意不是点的个数!一个点有两个数值。
count:参与绘制的数值个数,指pts数组中数值的个数,而不是点的个数。
paint:绘制时所使用的画笔。


5.画矩形


区别:


RectF 所保存的数值类型是 float 类型
Rect 所保存的数值类型是 int 类型


构造矩形的两种方法:


//方法一 直接构造
Rect rect = new Rect(10, 10, 100, 100);
//方法二 间接构造
Rect rect = new Rect();
rect.set(10, 10, 100, 100);

绘制矩形:


Paint paint = new Paint(); 
paint.setColor(Color.RED);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(15);

//直接构造
canvas.drawRect(10, 10, 100, 100, paint);

//使用 RectF 构造
RectF rect = new RectF(210f, 10f, 300f, 100f);
canvas.drawRect(rect, paint);

6.画圆角矩形


Paint paint = new Paint();
paint.setColor(Color.RED);
paint.setStyle(Style.FILL);
paint.setStrokeWidth(15);

RectF rect = new RectF(100,10,300,100);
canvas.drawRoundRect(rect,20,10, paint);

基本语法


void drawRoundRect (RectF rect, float rx, float ry,Paint paint)


参数说明


rect:要绘制的矩形。
rx:生成圆角的椭圆的X轴半径。
ry:生成圆角的椭圆的Y轴半径。
paint:绘制时所使用的画笔。


7.画椭圆


Paint paint = new Paint();
paint.setColor(Color.RED);
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(5);

RectF rect = new RectF(100,10,300,100);
canvas.drawRect(rect, paint);

canvas.drawOval(rect, paint);//根据同一个矩形画椭圆

基本语法


void drawOval(RectF oval, Paint paint)


参数说明


oval:用来生成椭圆的矩形。

收起阅读 »

40+场面试,100%通过率,我想分享的14条经验

作者 | 陈同学       责编 | 欧阳姝黎 这里是陈同学,首先来一个简单的自我介绍,和个人的经历分享吧。 我本科和硕士均就读于哈工大,是今年1月毕业。 我经历过3个专业,大一 船舶工程;大二-大四 车辆...
继续阅读 »

作者 | 陈同学       责编 | 欧阳姝黎


这里是陈同学,首先来一个简单的自我介绍,和个人的经历分享吧。


我本科和硕士均就读于哈工大,是今年1月毕业。


我经历过3个专业,大一 船舶工程;大二-大四 车辆工程;研一-研三 机械电子工程。


我拿过5个国家级竞赛的奖项 ,我在研究生期间从0开始,在1年时间,自学操作系统,计算机网络 ,C++,数据结构等等,累计学习30+本书,500+博客文章,100+小时的网课,30w+字的资料。


在实习阶段斩获了腾讯、阿里、华为等大厂的实习offer,在正式秋招阶段收割10+offer,包括但不限于


腾讯sp 

字节sp

阿里云 sp 

BAT大满贯

还有华为15a(应届生最高定级)

中兴蓝剑计划(应届生最高定级)

深信服大牛批(应届生最高定级)

vivo sp等等

均是40w+的总包

最高总包约50w

同时保持了一个在4月份以后

面试通过率100%的记录

今天和大家来分享一下,我从40+场面试中总结出来的14个应该避免的面试大坑。


我认为想面试互联网技术岗, 特别是像我一样的非科班同学,应该特别关注。


这些坑都是从我自身的经历以及从身边的同学的经历中总结出来的,我踩过的坑希望大家不要踩




No1.对简历上的每一个字负责


很多同学,包括我以前会犯的一个误区就是, 追求简历上技能点多多益善。


不论是不是自己真正掌握的 ,只要是接触过某个技术,都罗列在简历上。甚至有些技能点, 还蜜汁自信的写上“精通”但是面试官一深问, 就不会了。这就犯了写简历时候的一个大忌。


我们要对简历上的每一个字负责, 每一个写在简历上的技术点都应该是我们烂熟于心,经得起面试官深入追问的。


具体来说就是要避开下面两个坑



  1. 技术栈不要贪多把写上去的每一个点深入掌握就好。你在简历上写的内容相当于给面试官划定了一个出题范围。面试的时候面试官并不会特意的刁难你。他们主要还是会从你简历上写好的那些技术点去考你。好好对着自己写的简历一行一行看一遍,这都是你挖的坑。同时谨慎的使用熟练精通这些字眼 。


  2. 在描述项目的时候,不要过分夸张,比如把整个团队的活写成你一个人做的。言过其实,很容易会在面试中露馅,简历可以美化包装,但是过分夸张。





No2.技术宽度决定了你是否能够进入一家公司,


技术深度则决定了你offer的等级


对于互联网技术岗的主要问的东西有这样几块计算机学科基础+项目经历+刷题。这3块也就是整个面试的核心了,然后对于不同细分的技术岗位下对于这三块有不同的考察方向比如:



  • 对于开发岗可能考察的就是像操作系统计算机网络等等方面的知识


  • 对于算法岗考察的就是机器学习深度学习等等方面的内容



所以我觉得只有你先对应岗位必问的那些知识掌握,也就是先cover住技术宽度,才是拿到offer的前提。


在此基础上 如果你能在某一方面比较有优势,比如某一些知识领域比较精通或者做的项目比较有优势或者有大厂实习也就是技术深度达到了这样才能有更好的offer等级。


关于怎么提升宽度和深度,其实说真的短期内宽度是好补的,深度确实要看个人,是代价较高。


所以我的建议是,先把宽度提上来,把你能cover的知识点及原理搞懂是第一步。建议对自己之前的项目和技术积累做一个总结和分类。


然后对已经了解的方面尽可能延伸,对盲区或是一些面试重点考察的地方进行针对性的学习和练习。




No3.如果走技术研发岗,学历、成绩、奖学金 


学生组织活动都不会是决定性的因素


因为面试中只考查计算机基础+刷题+项目,只有在最后的HR面的时候才会问一下你的在校的一些经历、奖学金等等。


当然如果你如果前面的技术面都通过的话,最后的HR面其实问题不大,就算没有太多的学生组织经历、太高的绩点、各种奖学金等等。HR面大概率还是会通过的。


只有你的技术水平才是决定性因素像学历、绩点、奖学金等等这些东西只是一个锦上添花。


如果你的技术很拉跨,一个技术问题都回答不上来,我觉得算是清北,面试官也是大概率不会让你通过的。


互联网算是对学历最宽容的行业之一毕竟程序员是一个技术密集型工种。


学校的作用是抬高找工作的下限,很多大厂会认为一个出身名校的同学的基本功是扎实的,因此会很乐于接纳这样的同学。但是指望名校光环提高自己的上限是不切实际的。


有很多同学会因为自己是双非学校,感到自卑,不敢投递大厂会显得有点畏手畏脚。但我觉得我们完全没有必要妄自菲薄


说实话,我自己本科专业也和计算机一点不搭边,在面试的时候也和面试官提到这个问题,但面试官给我的答复是只要有能力,没有人会看你的学校或者专业。




No4.心态作为一个很重要的因子存在,


还是会对最后的结果有挺大影响的


这里给大家列出一个公式 是我在某一个帖子看到的


  offer = 心态 * (实力 + 面试技巧) + 运气

实力就是咱们刚才所说的 计算机基础+刷题+项目


秋招对大部分人来说都是一场难熬的经历,会有各种压力源的存在,真的很容易让我们心态崩溃



  • 可能有的同学开始准备的时间比较晚,快开始秋招了才开始准备,总暗示自己说什么时间不多了,怎么每天过这么快效率怎么这么低。


  • 到笔试了,跟自己说这个算法太难了,肯定做不出来;


  • 面试过程中面试官问的东西好多都不会怎么办?


  • 面完了又收到拒信,这次面试又凉凉了。


  • 周围的XX大佬又收割一个offer了 我还没上岸 太菜了 怎么办



不管是面试前、面试中、面试后的结果 已经周围环境 peer pressure 等等都牵动着我们的神经。


所以这里给大家提供几个调节心态的小建议



  • 要正视自己的能力,不轻视,不高估

    不轻视指的是我们都要对自己有信心,机会那么多,千千万万的初中创公司,各种拥有垂直领域稳定份额的二三线公司甚至有些已经上市,除此之外还有银行,投资,金融的IT岗

    不高估就是要清楚自己的能力范围,过高的期望会让你的心理变得脆弱,稍有不顺心态就有崩掉的趋势。因为面试毕竟有太大的偶然性,就算你达到了一定的水平,相应水平的岗位也不是百发百中的


  • 遭受到各种拒绝时,一定要沉得住气,坚信一切都会是最好的安排

    在确保自身没有问题(学习方法、知识积累或自身定位)的情况下,坚持下去,这个时候你差的就是一点点运气,该来的总会来。面试过程不要紧张,尤其是前几次,建议先从小公司入手锻炼下面试经验


  • 心态实在太差的时候反而要停下你重复而没有效率的工作,去调整一下,可以出去玩一玩,吃吃喝喝


  • 面试过程漫长:适当放松,面试很搞人心态的

    过了简历面等 一面 一面过了等二面 二面过了等三面。互联网面试流程少则三面 多则五六七八面。持续时间少则是、一个礼拜 多则一两个月 。在这个过程中建议大家专注于过程 不要太在意结果


  • 面试准备过程中 和周围同学多交流 不比较
    主要是要找一个能力和你差不多的同学,最好不要找那种比你强太多的,当你看到别人已经收割很多offer了自己还颗粒无收的时候 容易被搞心态,会怀疑人生。当然也不排除有些人拿到offer后在朋友圈装X、散布焦虑情绪,这种我建议屏蔽或拉黑,同时也希望大家拿到offer后能低调一些,以己度人。求职过程中别和身边的人对比 ,别自我怀疑,专注于过程,别在意结果,反思总结,心态别崩





No5.学会平等交流,别把自己身段放的太低


面试是个双选的过程,他可以拒绝你,你也可以拒绝他。回答的时候不用表现的太卑微,反而会影响自己正常的表达和逻辑,不卑不亢就行。


心态也放稳一点,大胆一点,duck不必害怕,互联网技术岗的面试不会像其他行业 其他岗位比如快销,地产等等那样子会在意你的仪表,谈吐等等,他在意的就是面试官问你的技术会不会。


和面试官谈笑风生就行了,而且1面面试官可能只比我们大几岁,如果进去了还是你mentor呢。




No6.回答问题的时候要有层次感 循序渐进


不要一口气把知道的全部说完,然后还毫无条理。学会一个知识点由浅入深讲解给面试官,并且留有余地给他进一步去问。


一个简单的基础问题可以一步一步有条理有层次的回答,每一层表达完抛个引子,让面试官可以继续问下去,这也算是一个引导的技巧,从而让面试官真正了解你的掌握的深度。




No7.如果真的被问到不会的,就直接说你不会


每个程序员都不是全能的大神,总会有知识漏洞,更何况是我们这些应届生所以面试中碰到不会的问题很正常。


不要觉得自己某个问题到不上来,这场面试就注定凉凉了,坦诚的告诉面试官自己不会,或者礼貌地说这方面可能我还要多学习。


对一个拿不准的问题千万不要猜,即使是二选一的那种问题,猜错了直接完蛋,猜对了被人看出来,再往深问还是完蛋。


另外,像可能,大概是,我觉得这种表达最好不要,一听就是对一个点没把握,有可能会让面试官觉得学习太浮躁不喜欢寻求原理。


那对于自己知道原理(确实是理解了的)但是没用过的东西,就讲讲原理,并承认自己实践不足,表现出好学的态度。


面试一定要真诚。不熟直接说不会,更多的展示自己擅长的一面,千万不懂装懂。




No8.手撕代码题的时候主动的和面试官交流


一般每一轮面试的最后一part保留节目是手撕代码。


关于手撕代码部分,不能面试官出完题,就一个人闷头在那里写。


因为面试官是会代入实际工作时的情景的,如果你写题的时侯和他一点交流也没有,那万一把你招进去了以后对需求交接的时侯是不是也是这样的状态?


这个也是我在面试的时侯听面试官提的意见。




No9.思路比答对题目更重要,题不会没关系,


你要体现你的解题思路和能力


当然纯概念不会就是不会,别瞎说。


这里更多的是比如一些开放性的题目,比如说,手撕代码题,项目中的一些优化 一些系统设计题、智力题。


面试官不一定非得要求有一个标准答案呢,主要是想看看你能不能主动的去拆解问题、主动思考,以及和面试官的交流。


这也是面试中考察的很重要的一部分,就是你解决问题的能力。


对于这种问题,还是要多打开思路,多结合自己已经学过的一些技术点进行思考。


自己能够先给出一个简单的方案,再一步一步的优化,到一个相对合理的方案 这样的回答面试官会非常喜欢。




No10.最好把每场面试录音,记录面经,反思总结


在电话面或者视频面的时候 ,最好利用手机的录音功能把每一场面试录下来哦 这样方便自己的复盘 。


发现自己那些模块比较薄弱,查漏补缺, 反思总结, 针对面试中出现的问题下次不要再出现。




No11.在面试中介绍项目的面试时候,


项目的一些描述要提前准备,而不是临场去组织语言


很多同学在面试中描述项目的时候,都是临场发挥,临场去组织语言。这样会往往会导致你在介绍的时候,不流畅不连贯 ,导致面试官抓不住你的重点。


也就会让它认为你的表达有问题,或者你的项目吗没有太核心能吸引他的东西,所以建议大家专门给自己做的项目整理一个类似演讲稿的稿子。


把项目的流程、项目的背景、项目碰到的问题。自己用到的方案,项目的亮点难点改进点,后续的优化方向等等都写在这个稿子上。


在每次面试前过一遍,这样的在面试中直接按照稿子上的描述去说就行。


面试官其实对你的项目业务流程不感兴趣,更感兴趣的是你项目中



  • 自己解决的问题,


  • 所采用的方案,


  • 为什么采用这个方案,


  • 有没有更好的方案,


  • 你的方案和别人的方案的对比,


  • 你的思考在哪里,


  • 你的难点亮点创新点,


  • 以及在项目中所涉到的技术点的一些提问,



这里面最好可以涉及一些数据,比如数据量、响应速度等等来量化的表达。




No12.把握好反问环节


面试官最后一般会问你你有什么想问我的,这个其实就是反问环节。


这个其实是面试官想了解你对公司的一个关注度或者对自身发展的一个关注度。


所以大家可以从这些角度去问新人培养机制?进去以后负责哪些业务?学习建议?


表现出自己的好学求知,以及对公司的关注 这也能看出你对工作的一个诚意,以及对发展的一个预期。


最好不要去问那些比如 “我什么时候会有下一面 ” “我刚刚面的怎么样这种话题”。




No13. HR面的时候 看起来像聊人生 


实际是在考察你的价值观


到HR面的时候就不会在有技术问题了,而是一些看起来无关痛痒的聊生活聊兴趣。


比如,家里人都是干嘛的,有没有女朋友,有没有什么兴趣爱好,有没有拿到别的offer,为什么会来我们呢公司等等。


其实这些问题看起来都很无足轻重,实际上是想看看你的稳定性,是不是适合公司的氛围,是不是接受公司的文化等等。


比如,是不是会因为家里条件好,吃不了苦,加不了班,会不会女朋友异地,过几年就会离职跳槽,稳定性差,会不会有更好的offer放弃这家等等。


所以大家在HR面的时候要摸清楚HR真正想考察你的指标是什么避免跳坑里就行了。


对于互联网技术岗来讲 通过了前面的3、4轮的技术面 一般问题都不大,HR面只要不是回答得得太离谱,offer八成是可以到手的




No14.不要把鸡蛋都放在一个篮子里


这句话的意思是, 尽量多拿几个offer,不要只拿一个offer就躺平了,不要把赌注都压在一个offer上。


因为互联网的秋招一般是面试通过了,先发两方,然后过两个月左右到11月份再谈薪资。


如果你最后只拿了一个offer,然后那个公司又只给你开了一个白菜价你就血亏了,都没有别的选择。


尽量多拿一些offer。事实证明,部分企业会根据你手里offer的情况来定薪资,还有一点,万一后面提前去实习发现不太合适,想违约跑路 没有别的offer在手,根本没有选择。


hr们会养备胎,你也可以多拿几个offer ,算是给自己多养几个备胎,抵抗风险。


收起阅读 »

震惊:从头开发一个RPC是种怎样的体验?

RPC
对于开发人员来说,调用远程服务就像是调用本地服务一样便捷。尤其是在微服务盛行的今天,了解RPC的原理过程是十分有必要的。 作者 | Alex Ellis       译者 | 弯月 出品 | CSDN(ID:CS...
继续阅读 »


对于开发人员来说,调用远程服务就像是调用本地服务一样便捷。尤其是在微服务盛行的今天,了解RPC的原理过程是十分有必要的。


作者 | Alex Ellis       译者 | 弯月


出品 | CSDN(ID:CSDNnews)


以下为译文:


计算机之间的通信方式多种多样,其中最常用的一种方法是远程过程调用(Remote Procedure Call,即RPC)。该协议允许一台计算机调用另一个计算机上的程序,就像调用本地程序一样,并负责所有传输和通信。


假设我们需要在一台计算机上编写一些数学程序,并且有一个判断数字是否为质数的程序或函数。在使用这个函数的时候,我们只需传递数字进去,就可以获得答案。这个函数保存在我们的计算机上。



很多时候,程序保存在本地非常方便调用,而且由于这些程序与我们其余的代码在一起,因此调用的时候几乎不会产生延迟。


但是,在有些情况下,将这些程序保留在本地也不见得是好事。有时,我们需要在拥有大量核心和内存的计算机上运行这些程序,这样它就可以检查非常大的数字。但这也不是什么难事,我们可以将主程序也放到大型计算机上运行,即使其余的程序可能并没有这种需求,质数查找函数也可以自由利用计算机上的资源。如果我们想让其他程序重用质数查找函数,该怎么办?我们可以将其转换成一个库,然后在各个程序之间共享,但是每一台运行质数查找库的计算机,都需要大量的内存资源。


如果我们将质数查找函数单独放在一台计算机上,然后在需要检查数字时与该计算机对话,怎么样呢?如此一来,我们就只需提高质数查找函数所在的计算机的性能,而且其他计算机上程序也可以共享这个函数。



这种方式的缺点是更加复杂。计算机可能会出现故障,网络也有可能出问题,而且我们还需要担心数据的来回传递。如果你只想编写一个简单的数学程序,那么可能无需担心网络状况,也不用考虑如何重新发送丢失的数据包,甚至不用担心如何查找运行质数查找函数的计算机。如果你的工作是编写最佳质数查找程序,那么你可能并不关心如何监听请求或检查已关闭的套接字。


这时就可以考虑远程过程调用。我们可以将计算机间通信的复杂性包装起来,然后在通信的任意一侧建立一个简单的接口(stub)。对于编写数学程序的人来说,看上去就像在调用同一台计算机上的函数;而对于编写质数查找程序的人来说,看上去就像是自己的函数被调用了。如果我们将中间部分抽象化,那么两侧都可以专心做好自己的细节,同时仍然可以享受将计算拆分到多台计算机的优势。



RPC调用的主要工作就是处理中间部分。它的一部分必须存在数学程序的计算机上,负责接受并打包参数,然后发送到另一台计算机。此外,在收到响应后,还需要解析响应,并传递回去。而质数查找函数计算机则必须等待请求,解析参数,然后将其传递给函数,此外,还需要获取结果,将其打包,然后再返回结果。这里的关键之处是数学程序和质数查找程序间,以及它们的stub之间都有一个清晰的接口。



更多详细信息,请参见 Andrew D. Birrell和Bruce Jay Nelson1 于1981年发表的论文《Implementing Remote Procedure Calls》。



从头编写RPC


下面,我们来试试看能不能编写一个RPC。


首先,我们来编写基本的数学程序。为了简单起见,我们编写一个命令行工具,接受输入,然后检查是否为质数。它有一个单独的方法is_prime,处理实际的检查。


// basic_math_program.c
#include <stdio.h>
#include <stdbool.h>


// Basic prime checker. This uses the 6k+-1 optimization
// (see https://en.wikipedia.org/wiki/Primality_test)
bool is_prime(int number) {
// Check first for 2 or 3
if (number == 2 || number == 3) {
return true;
}
// Check for 1 or easy modulos
if (number == 1 || number % 2 == 0 || number % 3 == 0) {
return false;
}
// Now check all the numbers up to sqrt(number)
int i = 5;
while (i * i <= number) {
// If we've found something (or something + 2) that divides it evenly, it's not
// prime.
if (number % i == 0 || number % (i + 2) == 0) {
return false;
}
i += 6;
}
return true;
}


int main(void) {
// Prompt the user to enter a number.
printf("Please enter a number: ");
// Read the user's number. Assume they're entering a valid number.
int input_number;
scanf("%d", &input_number);


// Check if it's prime
if (is_prime(input_number)) {
printf("%d is prime\n", input_number);
} else {
printf("%d is not prime\n", input_number);
}


return 0;
}

这段代码有一些潜在的问题,我们没有处理极端情况。但这里只是为了说明,无伤大雅。



目前一切顺利。下面,我们将代码拆分成多个文件,is_prime 可供同一台计算机上的程序重用。首先,我们为 is_prime 创建一个单独的库:


// is_prime.h
#ifndef IS_PRIME_H
#define IS_PRIME_H


#include <stdbool.h>


bool is_prime(int number);


#endif

// is_prime.c
#include "is_prime.h"


// Basic prime checker. This uses the 6k+-1 optimization
// (see https://en.wikipedia.org/wiki/Primality_test)
bool is_prime(int number) {
// Check first for 2 or 3
if (number == 2 || number == 3) {
return true;
}
// Check for 1 or easy modulos
if (number == 1 || number % 2 == 0 || number % 3 == 0) {
return false;
}
// Now check all the numbers up to sqrt(number)
int i = 5;
while (i * i <= number) {
// If we've found something (or something + 2) that divides it evenly, it's not
// prime.
if (number % i == 0 || number % (i + 2) == 0) {
return false;
}
i += 6;
}
return true;
}

下面,从主程序中调用:


// basic_math_program_refactored.c
#include <stdio.h>
#include <stdbool.h>


#include "is_prime.h"


int main(void) {
// Prompt the user to enter a number.
printf("Please enter a number: ");
// Read the user's number. Assume they're entering a valid number.
int input_number;
scanf("%d", &input_number);


// Check if it's prime
if (is_prime(input_number)) {
printf("%d is prime\n", input_number);
} else {
printf("%d is not prime\n", input_number);
}


return 0;
}

再试试,运行正常!当然,你也可以加一些测试:



下面,我们需要将这个函数放到其他计算机上。我们需要编写的功能包括:



  • 调用程序的 stub:




  • 打包参数


  • 传输参数


  • 接受结果


  • 解析结果




  • 被调用的 stub:




  • 接受参数


  • 解析参数


  • 调用函数


  • 打包结果


  • 传输结果



我们的示例非常简单,因为我们只需要打包并发送一个 int 参数,然后接收一个字节的结果。对于调用程序的库,我们需要打包数据、创建套接字、连接到主机(暂定 localhost)、发送数据、等待结果、解析,然后返回。调用程序库的头文件如下所示:


// client/is_prime_rpc_client.h
#ifndef IS_PRIME_RPC_CLIENT_H
#define IS_PRIME_RPC_CLIENT_H


#include <stdbool.h>


bool is_prime_rpc(int number);


#endif

可能有些读者已经发现了,实际上这个接口与上面的函数库一模一样,但关键就在于此!因为调用程序只需要关注业务逻辑,无需关心其他一切。但实现就稍复杂:


// client/is_prime_rpc_client.c


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>


#define SERVERPORT "5005" // The port the server will be listening on.
#define SERVER "localhost" // Assume localhost for now


#include "is_prime_rpc_client.h"


// Packs an int. We need to convert it from host order to network order.
int pack(int input) {
return htons(input);
}


// Gets the IPv4 or IPv6 sockaddr.
void *get_in_addr(struct sockaddr *sa) {
if (sa->sa_family == AF_INET) {
return &(((struct sockaddr_in*)sa)->sin_addr);
} else {
return &(((struct sockaddr_in6*)sa)->sin6_addr);
}
}


// Gets a socket to connect with.
int get_socket() {
int sockfd;
struct addrinfo hints, *server_info, *p;
int number_of_bytes;


memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM; // We want to use TCP to ensure it gets there
int return_value = getaddrinfo(SERVER, SERVERPORT, &hints, &server_info);
if (return_value != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(return_value));
exit(1);
}


// We end up with a linked-list of addresses, and we want to connect to the
// first one we can
for (p = server_info; p != NULL; p = p->ai_next) {
// Try to make a socket with this one.
if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
// Something went wrong getting this socket, so we can try the next one.
perror("client: socket");
continue;
}
// Try to connect to that socket.
if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
// If something went wrong connecting to this socket, we can close it and
// move on to the next one.
close(sockfd);
perror("client: connect");
continue;
}


// If we've made it this far, we have a valid socket and can stop iterating
// through.
break;
}


// If we haven't gotten a valid sockaddr here, that means we can't connect.
if (p == NULL) {
fprintf(stderr, "client: failed to connect\n");
exit(2);
}


// Otherwise, we're good.
return sockfd;
}


// Client side library for the is_prime RPC.
bool is_prime_rpc(int number) {


// First, we need to pack the data, ensuring that it's sent across the
// network in the right format.
int packed_number = pack(number);


// Now, we can grab a socket we can use to connect see how we can connect
int sockfd = get_socket();


// Send just the packed number.
if (send(sockfd, &packed_number, sizeof packed_number, 0) == -1) {
perror("send");
close(sockfd);
exit(0);
}


// Now, wait to receive the answer.
int buf[1]; // Just receiving a single byte back that represents a boolean.
int bytes_received = recv(sockfd, &buf, 1, 0);
if (bytes_received == -1) {
perror("recv");
exit(1);
}


// Since we just have the one byte, we don't really need to do anything while
// unpacking it, since one byte in reverse order is still just a byte.
bool result = buf[0];


// All done! Close the socket and return the result.
close(sockfd);
return result;
}

如前所述,这段代码需要打包参数、连接到服务器、发送数据、接收数据、解析,并返回结果。我们的示例相对很简单,因为我们只需要确保数字的字节顺序符合网络字节顺序。


接下来,我们需要在服务器上运行被调用的库。它需要调用我们前面编写的 is_prime 库:


// server/is_prime_rpc_server.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <arpa/inet.h>
#include <sys/wait.h>
#include <signal.h>
#include "is_prime.h"
#define SERVERPORT "5005" // The port the server will be listening on.
// Gets the IPv4 or IPv6 sockaddr.
void *get_in_addr(struct sockaddr *sa) {
if (sa->sa_family == AF_INET) {
return &(((struct sockaddr_in*)sa)->sin_addr);
} else {
return &(((struct sockaddr_in6*)sa)->sin6_addr);
}
}
// Unpacks an int. We need to convert it from network order to our host order.
int unpack(int packed_input) {
return ntohs(packed_input);
}
// Gets a socket to listen with.
int get_and_bind_socket() {
int sockfd;
struct addrinfo hints, *server_info, *p;
int number_of_bytes;
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM; // We want to use TCP to ensure it gets there
hints.ai_flags = AI_PASSIVE; // Just use the server's IP.
int return_value = getaddrinfo(NULL, SERVERPORT, &hints, &server_info);
if (return_value != 0) {
fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(return_value));
exit(1);
}
// We end up with a linked-list of addresses, and we want to connect to the
// first one we can
for (p = server_info; p != NULL; p = p->ai_next) {
// Try to make a socket with this one.
if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {
// Something went wrong getting this socket, so we can try the next one.
perror("server: socket");
continue;
}
// We want to be able to reuse this, so we can set the socket option.
int yes = 1;
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
// Try to bind that socket.
if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {
// If something went wrong binding this socket, we can close it and
// move on to the next one.
close(sockfd);
perror("server: bind");
continue;
}
// If we've made it this far, we have a valid socket and can stop iterating
// through.
break;
}
// If we haven't gotten a valid sockaddr here, that means we can't connect.
if (p == NULL) {
fprintf(stderr, "server: failed to bind\n");
exit(2);
}
// Otherwise, we're good.
return sockfd;
}
int main(void) {
int sockfd = get_and_bind_socket();
// We want to listen forever on this socket
if (listen(sockfd, /*backlog=*/1) == -1) {
perror("listen");
exit(1);
}
printf("Server waiting for connections.\n");
struct sockaddr their_addr; // Address information of the client
socklen_t sin_size;
int new_fd;
while(1) {
sin_size = sizeof their_addr;
new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);
if (new_fd == -1) {
perror("accept");
continue;
}
// Once we've accepted an incoming request, we can read from it into a buffer.
int buffer;
int bytes_received = recv(new_fd, &buffer, sizeof buffer, 0);
if (bytes_received == -1) {
perror("recv");
continue;
}
// We need to unpack the received data.
int number = unpack(buffer);
printf("Received a request: is %d prime?\n", number);
// Now, we can finally call the is_prime library!
bool number_is_prime = is_prime(number);
printf("Sending response: %s\n", number_is_prime ? "true" : "false");
// Note that we don't have to pack a single byte.
// We can now send it back.
if (send(new_fd, &number_is_prime, sizeof number_is_prime, 0) == -1) {
perror("send");
}
close(new_fd);
}
}

最后,我们更新一下我们的主函数,使用新的RPC库调用:


// client/basic_math_program_distributed.c
#include <stdio.h>
#include <stdbool.h>
#include "is_prime_rpc_client.h"
int main(void) {
// Prompt the user to enter a number.
printf("Please enter a number: ");
// Read the user's number. Assume they're entering a valid number.
int input_number;
scanf("%d", &input_number);
// Check if it's prime, but now via the RPC library
if (is_prime_rpc(input_number)) {
printf("%d is prime\n", input_number);
} else {
printf("%d is not prime\n", input_number);
}
return 0;
}

这个 RPC 实际的运行情况如下:


现在运行服务器,就可以运行客户端将质数检查的工作分布到其他计算机上运行!现在,程序调用 is_prime_rpc 时,所有网络业务都在后台进行。我们已经成功分发了计算,客户端实际上是在远程调用程序。



示例有待改进的方面


本文中的实现只是一个示例,虽然实现了一些功能,但只是一个玩具。真正的框架(例如 gRPC3)要复杂得多。我们的实现需要改进的方面包括:



  • 可发现性:在上述示例中,我们我们假定服务器在 localhost 上运行。RPC 库怎么知道将 RPC 发送到哪里呢?我们需要通过某种方式来发现可以处理此 RPC 调用的服务器在哪里。


  • RPC 的类型:我们的的服务器非常简单,只需处理一个 RPC 调用。如果我们希望服务器提供两个不同的RPC服务,比如 is_prime 和get_factors,那么该怎么办?我们需要一种方法来区分发送到服务器的两种请求。


  • 打包:打包整数很容易,打包一个字节更容易。如果我们需要发送一个复杂的数据结构,该怎么办?如果我们需要为了节省带宽而压缩数据,又该怎么办?


  • 自动生成代码:我们肯定不希望每次编写新的 RPC,都需要手动编写所有的打包和网络处理代码。理想情况下,我们只需定义一个接口,然后其余的接口都由计算机自动完成,并自动提供 stub。这里,我们需要考虑协议缓冲区等。


  • 多种语言:按照上面的思路,如果我们能够自动生成 stub,那么就可以考虑支持多种语言,如此一来,跨服务和跨语言的通信也只需调用一个函数。


  • 错误和超时处理:如果 RPC 失败怎么办?如果网络出现故障,服务器停止运行,wifi 掉线,该怎么办?我们需要考虑超时处理。


  • 版本控制:假设上述所有功能已全部实现,但你想修改某个正在多台计算机上运行的 RPC,那么该怎么办?


  • 其他有关服务器的注意事项:线程、阻塞、多路复用、安全性、加密、授权等等。



计算机科学就是要站在巨人的肩膀上,很多库已经为我们完成了大量工作。


原文链接:https://alexanderell.is/posts/rpc-from-scratch/


声明:本文由CSDN翻译,转载请注明来源。



收起阅读 »

Google和腾讯为什么都采用主干开发模式?

作者 | 黄国峰       责编 | 欧阳姝黎 摘要 本文介绍了两种常用的代码分支模式:特性分支开发模式、主干开发模式,分别阐述了其优缺点和适用环境;同时剖析了 Google 和腾讯采用主干开发模式的背景...
继续阅读 »

作者 | 黄国峰       责编 | 欧阳姝黎




摘要


本文介绍了两种常用的代码分支模式:特性分支开发模式、主干开发模式,分别阐述了其优缺点和适用环境;同时剖析了 Google 和腾讯采用主干开发模式的背景和决策因素,捎带分享了这2个巨头的实践,供读者在技术选型中参考。




背景


按之前的写作思路,本文应该叫《Google 工程效能三板斧之三:主干开发》,但我改变了主意,希望能同时提供国内互联网公司的实践,供读者参考,因此文章标题也随之更改。


软件开发过程中,开发人员通过版本管理工具对源码进行存储,追踪目录和文件的修改历史。为了区隔不同状态的源代码,会采用分支进行管理。不同的软件开发模式,对应着不同的分支模式。


软件业界常用的软件分支模式有多种,但本质上可以分为两类:



  • 主干开发模式(Trunk Based Development)


  • 特性分支开发模式(Feature Branch Development)





两种模式的定义及优缺点分析


特性分支开发模式


特性分支开发模式是指为一个或多个特定的需求/缺陷/任务创建代码分支(branch),在其上完成相应的开发(一般经过增量测试)后,把它合并(merge)到主干/集成分支的开发模式。


通常这种分支生命期会持续一段时间,从几天到几周不等,极少数情况甚至以月算。


特性分支开发模式中常用的有 Git-Flow 模式、Github-Flow 模式和 Gitlab-Flow 模式等。这些模式只有细节上的差异,以 Git-Flow为例:



优点:



  • 特性开发周期宽松:因为生命期可以较长,较大的需求特性可以在宽松的时间内完成再合入主干;


  • 分支测试的时间宽松:因为生命期可以较长,可以有较多时间对分支进行测试,甚至手工测试;



缺点:



  • 分支管理复杂:原因在于大量采用代码分支,且来源分支和合入目标分支各异,操作复杂 —— 以上图为例,可以从master(Tag 1.0.0) 拉出 hotfix 1.0.2 分支,然后合入到 develop 分支,开发阶段结束后合入到 release branches,发布后合入 master,非常复杂,很容易出错;


  • 合并冲突多、解决难:分支生命期越长,意味着与主干的代码差异越大,冲突概率越高,冲突的解决难度越大(甚至成为不可能);


  • 迭代速度慢:特性分支生命期长(数天至数周)意味着特性上线速度慢,相应的迭代速度也慢;


  • 需要较多测试环境:每个特性分支都需要分配至少1个测试环境,且长期占用(有状态);



适用环境:



  • 对版本迭代速度要求不高


  • 测试自动化程度低,或说主要靠人工测试的



主干开发模式


主干开发,是指开发人员直接向主干(习惯上主干分支通常为:trunk 或 master)提交/推送代码。通常,开发团队的成员1天至少1次地将代码提交到主干分支。在到达发布条件时,从主干拉出发布分支(通常为 release),用于发布。若发现缺陷,直接在主干上修复,并根据需要 cherry pick 到对应版本的发布分支。


流程:



优点:



  • 分支模型简单高效,开发人员易于掌握不容易出现错误操作


  • 避免了分支合并、冲突解决的困扰


  • 随时拥有可发布的版本


  • 有利于持续集成和持续交付



缺点:



  • 基础架构要求高:合入到主干的代码若质量不过关将直接阻塞整个团队的开发工作,因此需要高效的持续集成平台进行把关;


  • 自动化测试要求高:需有完备单元测试代码,确保在代码合入主干前能在获得快速和可靠的质量反馈;


  • 最好有代码评审:若代码质量要求高,需要配套代码评审(CR)机制,在代码提交到主干时,触发CR,通过 Peer Review 后才能正式合入;


  • 最好有特性开关:主干开发频发合入主干的情况下,特性拆分得很小,可能是半成品特性,需要配套特性开关(Feature Toggle),只有当特性整体开发完才通过灰度发布等手段逐步打开;



适用环境:



  • 对迭代速度要求高,希望需求快速交付上线


  • 基础架构强,持续集成工具高效;


  • 团队成员习惯TDD(测试驱动开发),代码自动化测试覆盖率高(至少增量代码的自动化测试覆盖率高);





为什么 Google 和腾讯采用主干开发模式


互联网巨头 Google 大部分业务开发都采用主干开发模式,国内巨头腾讯也在推行主干开发(试点业务团队大部分已经采用)。


他们采用主干开发的原因在于对主干开发的优点有强烈诉求,而且有能力和资源弥补其缺点:



  • 都是互联网企业,竞争激烈,因此对迭代速度要求高;


  • 基础架构能力强:都能自研强大的持续集成平台,Google 有自研的 Forge,腾讯有自研的蓝盾;


  • 自动化测试能力强:都推行TDD,强调开发负责质量,减少甚至取消手工测试人员(少量必要的手工测试转外包),自动化测试覆盖率高;


  • 都有严格的CR机制确保代码质量:Google 极其严苛的可读性认证(Readability)在业界已经是标杆,腾讯是国内少有正在采用类似实践的互联网企业。严格的代码可读性认证和根据此标准执行的严格代码评审制度,能有效的保证合入主干的代码质量不会降低。



主干开发的最大优点是:效率和质量,而这2者是软件和互联网企业的核心诉求。主干开发的缺点,巨头有能力和资源来填平这些坑。


因此,从ROI(Ratio of Investment)的角度来看,Google 和腾讯采用主干开发实属必然。




美中两巨头的实践


Google 在主干开发的实践


我们在之前的文章提到,Google 的工程效能(也叫研发效能)核心理念只有简单的3条:



  1. 使用单体代码仓库(参考:Google 工程效能三板斧之一:单体代码仓库


  2. 使用 Bazel 构建(参考:Google 工程效能三板斧之二:使用 Bazel 构建


  3. 主干开发;



其中的第3条,就是本文所述内容。


为了保证主干代码的质量,避免出现工程师合入到主干的代码 break 掉主干的情况,Google 采取了以下实践:



  • 代码合入事件触发通过持续集成,确保合入到主干的代码经过充分且必要测试;


  • 通过 Bazel 实现相关代码(指依赖变更代码的代码)的精准测试;


  • 至少 2 个合资格的 reviewer (代码评审人)的 LGTM(Look Good To Me),才允许代码合入主干;


  • 合资格的 reviewer 都是在 Google 内部通过 Readability (代码可读性)认证的员工;



腾讯在主干开发的实践


腾讯某 BG 在2018年开始的“930变革”后,在各试点团队推动主干开发(注:并未全公司普遍采用),具体的举措包括:



  1. 以度量牵引:通过对特性分支)的生命期监控和预警,实现非主干分支的生命期缩短,倒逼开发团队采用主干开发;


  2. 投大力气统一 BG 内的持续集成工具、开发自动化测试平台;


  3. 制定了 7 大编程语言的编码规范,并自研代码静态扫描工具;


  4. 并参考 Google 推行代码可读性(Readability)、可测试性(Testability)认证制度;


  5. 强力推行 CR (代码评审)制度,确保代码的可读性(命名、代码风格、设计、复杂度)。



效果:



  • 质量提升:代码质量从可测量的维度得到明显提升(代码规范率、单元测试覆盖率);


  • 迭代速度提升:试点团队的迭代周期从4周或2周提升至1周;


  • 代码从“私有”变“公有”:通过代码评审制度,提高了代码可读性,使代码从个人拥有(只有写代码的人能看懂),变成团队拥有(整个团队都能看懂);这一点对于企业非常重要,接手过别人代码的程序们都有感受;


  • 代码的自动化测试覆盖率提升明显,为未来的重构构筑了一张安全网;





中小企业能参考什么?


中小企业应该选择特性分支开发模式,还是主干开发模式?根据上文,相信大家已经足以自行判断。


有些中小企业的技术决策者非常认可持续集成/持续交付的理念,从而更希望采用主干开发,但对于主干开发的缺点(或说弥补缺点的成本)存在顾虑。


对此,我有如下建议:



  • 基础架构要求:可以考虑采用开源软件,如持续集成采用 Jenkins、Travis CI、Gitlab CI等,通过简单部署可以投入使用;同时配合代码静态分析工具(如 SonarQube、CheckStyle),确保代码基本质量过关;


  • 自动化测试要求:工具上不存在障碍,现代编程语言(如java、go、c++)都有内建或第三方的单元测试框架;难点只在于成员的开发习惯,可以通过测试覆盖率工具,以增量覆盖率指标保证新增代码都有完备的自动化测试,从而逐步改变团队的研发文化;


  • 代码评审要求:开源的Git服务器(如 Gitlab)基本都支持 push hook,配合开源的 Gerrit 等CR工具,可以实现在代码推送(push)或 pull request(合入请求)时触发1个代码评审请求,实现评审通过后,代码才正式合入的功能;剩下的就是研发文化问题了,需要在团队内部推行代码规范、代码可读性等宣导和教育工作;


  • 发布时的特性开关:如果要求不高,可以通过代码 hard code 一个常量作为特性开关;如果要求高,也有开源的特性开关(比如:unleash、piranha、flipper)工具可供选择。



参考上述建议,并充分认识到主干开发的成本和困难的情况下,中小企业开发团队也并非不可以考虑主干开发的实践。


收起阅读 »

我不是个黑客,但我就喜欢安全。快看如何开拓你的开发价值!!

安卓逆向4-使用AndroidKiller插入广告页文章目录 任务要求 1.安装配置AndroidKiller 2.反编译和拷贝替换 3.反编译 任务要求 利用Androidki...
继续阅读 »




安卓逆向4-使用AndroidKiller插入广告页

文章目录







任务要求


利用Androidkiller重新做一遍添加启动页作业。


1.安装配置AndroidKiller


下载v1.3.1压缩包,解压后运行AndroidKiller.exe,提示“未检测到Java SDK环境”。
此时打开app-debug.apk,软件提示“APK 反编译失败,无法继续下一步源码反编译!”。


配置Java环境:打开AK,选择左上角的“配置”-Java-安装路径,选择Java的bin目录。
再次打开apk文件,仍然提示“反编译失败”。


报错原因是软件自带的apktool版本过旧,点击软件左上角“Android”-APKTOOL管理器,添加本地的apktool。


在这里插入图片描述


在这里插入图片描述


在这里插入图片描述




2.反编译和拷贝替换


??打开apk-debug.apk文件,软件会自动编译,效果如图。
"工程信息"模块包含app名称、包名、程序入口点,"工程管理"模块包含目录结构。
在这里插入图片描述
本次插入的广告页与上次作业相同,回顾一下需要插入哪些文件。
1.拷贝图片hands_make_dream.jpg:把要插入的图片拷贝到AndroidKiller_v1.3.1\projects\app-debug\Project\res\drawable目录下。


2.添加布局文件activity_advert.xml:把要插入的布局文件拷贝到AndroidKiller_v1.3.1\projects\app-debug\Project\res\layout目录下。
修改布局文件的编号:在AndroidKiller_v1.3.1\projects\app-debug\Project\smali\com\example\four目录下的R$layout.smali文件中,添加advert布局文件的自定义编号,如.field public static final text_view_without_line_height:I = 0x7f0b005f


3.添加广告页的smail文件:把广告页的两个文件advert.smaliadvert$1.smali拷贝到AndroidKiller_v1.3.1\projects\app-debug\Project\smali\com\example\four目录下。
修改smail文件编号:打开advert.smali文件,把文件编号0x7f09001c修改为编号0x7f0b005f。


4.修改包名:目标apk的包名是com.example.four,修改广告页的两个smail文件advert.smali和advert$1.smail,把原包名retwo_login全部替换为目标apk的包名信息four


5.修改仓库文件:在AndroidKiller_v1.3.1\projects\app-debug\Project目录下找到AndroidManifest.xml文件,修改activity信息,修改后的activity信息如下。


	<activity android:name="com.example.four.MainActivity"></activity>
<activity android:name="com.example.four.advert">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>



3.反编译


??在AndroidKiller_v1.3.1中选择"Android"-“编译”,即可一键编译和签名。
在这里插入图片描述


安卓手机安装app-debug_killer.apk,运行效果如下。
首页映入眼帘的是插入的广告页文字和图片,停留5秒后跳到正常页面。


在这里插入图片描述
在这里插入图片描述

收起阅读 »

别问我为啥用这个来扫二维码!做开发的都在用

zxing基本使用 官方提供了zxing在Android机子上的使用例子,https://github.com/zxing/zxing/tree/master/android,作为官方的例子,zxing-android考虑了各种各样的情况,包括多种解析格式、...
继续阅读 »

zxing基本使用


官方提供了zxing在Android机子上的使用例子,https://github.com/zxing/zxing/tree/master/android,作为官方的例子,zxing-android考虑了各种各样的情况,包括多种解析格式、解析得到的结果分类、长时间无活动自动销毁机制等。有时候我们需要根据自己的情况定制使用需求,因此会精简官方给的例子。在项目中,我们仅仅用来实现扫描二维码和识别图片二维码两个功能。为了实现高精度的二维码识别,在zxing原有项目的基础上,本文做了大量改进,使得二维码识别的效率有所提升。先来看看工程的项目结构。









1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
.
├── QrCodeActivity.java
├── camera
│   ├── AutoFocusCallback.java
│   ├── CameraConfigurationManager.java
│   ├── CameraManager.java
│   └── PreviewCallback.java
├── decode
│   ├── CaptureActivityHandler.java
│   ├── DecodeHandler.java
│   ├── DecodeImageCallback.java
│   ├── DecodeImageThread.java
│   ├── DecodeManager.java
│   ├── DecodeThread.java
│   ├── FinishListener.java
│   └── InactivityTimer.java
├── utils
│   ├── QrUtils.java
│   └── ScreenUtils.java
└── view
└── QrCodeFinderView.java

源码比较简单,这里不做过多地讲解,大部分方法都有注释。主要分为几大块,



  • camera


主要实现相机的配置和管理,相机自动聚焦功能,以及相机成像回调(通过byte[]数组返回实际的数据)。



  • decode


图片解析相关类。通过相机扫描二维码和解析图片使用两套逻辑。前者对实时性要求比较高,后者对解析结果要求较高,因此采用不同的配置。相机扫描主要在DecodeHandler里通过串行的方式解析,图片识别主要通过线程DecodeImageThread异步调用返回回调的结果。FinishListenerInactivityTimer用来控制长时间无活动时自动销毁创建的Activity,避免耗电。



  • utils


图片二维码解析工具类,以及获取屏幕宽高的工具类。



  • view


这个包里只有一个类QrCodeFinderView,官方原本是使用这个类绘制扫描区域框,并且必须在扫描区域里才能识别二维码。我把这个类稍作修改,仅仅用来展示扫描区域,实际在相机扫描二维码的时候,只要在SurfaceView区域范围内,结果都是有效的。



  • QrCodeActivity


启动类,包含相机扫描二维码以及选择图片入口。


zxing源码存在的问题及解决方案


zxing项目源码实现了基本的二维码扫描及图片识别程序,但下载过源码并直接运行的童鞋都知道,例子存在很多的问题,包括基本的识别精准度不高、扫描区域小、部分手机存在预览图形拉伸、默认横向扫描、还有自定义扫描界面困难等问题。


资源下载:zxing

收起阅读 »

不会管理日志,还做什么开发?

Logger 基本用法 简介 Simple, pretty and powerful logger for android 为Android提供的,简单、强大而且格式美观的工具 本质就是封装系统提供的Log类,加上一些分割线易于查找不同的Log;...
继续阅读 »


Logger 基本用法


简介




Simple, pretty and powerful logger for android
为Android提供的,简单、强大而且格式美观的工具


本质就是封装系统提供的Log类,加上一些分割线易于查找不同的Log;logcat中显示的信息可配置。最初的样子如下图



包含线程信息、Log所在的类、方法及所在行数。


这里我忍不住了,就先写了我最喜欢的功能,嘎嘎嘎~~
最最最基本的依赖和简单打印在第二页


我觉得最好的功能是:Logger支持设置日志保存到本地,这样的话就可以想上传上传了。做自己的日志管理系统倍爽!
不过日志保存的位置写死了。找位置的方法是
在Logger包里的 DiskLogAdapter类的构造函数,进入build()方法里。


public DiskLogAdapter() {
formatStrategy = CsvFormatStrategy.newBuilder().build();
}

进入build(),就可以找到相应的路径


@NonNull public CsvFormatStrategy build() {
if (date == null) {
date = new Date();
}
if (dateFormat == null) {
dateFormat = new SimpleDateFormat("yyyy.MM.dd HH:mm:ss.SSS", Locale.UK);
}
if (logStrategy == null) {
//地址在这里
String diskPath = Environment.getExternalStorageDirectory().getAbsolutePath();
String folder = diskPath + File.separatorChar + "logger";
HandlerThread ht = new HandlerThread("AndroidFileLogger." + folder);
ht.start();
Handler handler = new DiskLogStrategy.WriteHandler(ht.getLooper(), folder, MAX_BYTES);
logStrategy = new DiskLogStrategy(handler);
}
return new CsvFormatStrategy(this);
}

具体路径是:/storage/emulated/0/logger
每个文件最大为500K,源码贴出来~~~~
private static final int MAX_BYTES = 500 * 1024; // 500K averages to a 4000 lines per file


生成的文件名称为logs_0.csv 后面的数字会递增 源码贴出来~~~~
newFile = new File(folder, String.format("%s_%s.csv", fileName, newFileCount));




刚用markDown不太会用




我最喜欢的部分写完了,下面写点常规的操作吧。simple


一、依赖Logger


地址:https://github.com/orhanobut/logger
本来不想贴地址呢,github是个好东西,介于我两天前还不会用github,还是贴上吧,啦啦啦,我是莉莉的小叮当
github上介绍很详细了,但是我还是想粘贴一遍。


依赖


dependencies {
implementation 'com.orhanobut:logger:2.2.0'
}

初始化


Logger.addLogAdapter(new AndroidLogAdapter());

到这里Logger已经可以用了
Logger.d(“debug”);
Logger.e(“error”);
Logger.w(“warning”);
Logger.v(“verbose”);
Logger.i(“information”);
Logger.wtf(“What a Terrible Failure”);


下面写点我自己的Logger用法


    val formatStrategy = PrettyFormatStrategy.newBuilder()
.showThreadInfo(true) //(可选)是否显示线程信息。 默认值为true
.methodCount(1) // (可选)要显示的方法行数。 默认2
.methodOffset(5) // (可选)隐藏内部方法调用到偏移量。 默认5
.tag("doShare")//(可选)每个日志的全局标记。 默认PRETTY_LOGGER
.build()
Logger.addLogAdapter(AndroidLogAdapter(formatStrategy))//根据上面的格式设置logger相应的适配器
Logger.addLogAdapter(DiskLogAdapter())//保存到文件


资源下载:logger-master.zip


收起阅读 »

昨天我被开了,技术总监说:不会Arouter做什么架构师

ARouter,A framework for assisting in the renovation of Android componentization (帮助 Android App 进行组件化改造的路由框架) —— 支持模块间的路由、通信、解耦 官...
继续阅读 »


ARouter,A framework for assisting in the renovation of Android componentization (帮助 Android App 进行组件化改造的路由框架) —— 支持模块间的路由、通信、解耦


官方中文介绍:
https://github.com/alibaba/ARouter/blob/master/README_CN.md
(中文比英文文档,详尽得多…,良心文档啊)


基本使用


1.添加依赖

android {
defaultConfig {
javaCompileOptions {
annotationProcessorOptions {
//注解处理器需要的模块名,作为路径映射的前缀
arguments = [AROUTER_MODULE_NAME: project.getName()]
}
}
}
}

dependencies {
implementation 'com.alibaba:arouter-api:1.4.1'
annotationProcessor 'com.alibaba:arouter-compiler:1.2.2' //注解处理器,会将注解编译成Java类
}

2.添加注解

//注意:路劲至少两级,即xx/xx,前一个xx用于分组
@Route(path = "/test/second")
public class SecondActivity extends AppCompatActivity {
}

3.初始化SDK

一般在Application中初始化


ARouter.init(this);

4.使用

//很简单,一句话完成,可携带参数
ARouter.getInstance().build("/test/second").navigation();

原理浅析


从ARouter.getInstance().build("/test/second").navigation();出发,解释其跳转基本过程。
先上一张时序图:
在这里插入图片描述


1.ARouter.build(path)构建Postcard

ARouter只是对外统一的api接口,实现基本由_ARouter完成,所以构建Postcard也是由_ARouter,构建,build(path, extractGroup(path))中extractGroup方法,就是把/xx/xx中前面的xx转换为默认group的方法,这也是之前必须使用2级以上目录的原因。build到此就完成了,此时还没有完成映射到activity的任务,只是把path浅析了下。


2.Postcard.navigation()实现跳转

最后也是由_ARouter完成,在_ARouter.navigation时,首先调用LogisticsCenter.completion(postcard)完善postcard的信息,而completion方法,则完成了path到activity的转换关系。完善后,再调用_navigation完成最终跳转。


3.LogisticsCenter.completion(postcard)将path映射到activity

核心部分:


public synchronized static void completion(Postcard postcard) {
RouteMeta routeMeta = Warehouse.routes.get(postcard.getPath());
if (null == routeMeta) {
Class<? extends IRouteGroup> groupMeta = Warehouse.groupsIndex.get(postcard.getGroup());
if (null == groupMeta) {
throw new NoRouteFoundException();
} else {
// Load route and cache it into memory, then delete from metas.
try {
IRouteGroup iGroupInstance = groupMeta.getConstructor().newInstance();
iGroupInstance.loadInto(Warehouse.routes);
Warehouse.groupsIndex.remove(postcard.getGroup());
} catch (Exception e) {
throw new HandlerException();
}

completion(postcard); // Reload
}
} else {
postcard.setDestination(routeMeta.getDestination()); //destination就是需要跳转的Activity.class
......
}
}

首先去Warehouse的routes中寻找RouteMeta(路由元数据)。
Warehouse可以理解为存储路由元数据的容器,包括:路由关系、拦截器、provider的映射关系等。RouteMeta既持有activity等对应跳转类信息。
首次navigation时,RouteMeta == null,故会用postcard build时的group path先找到对一个的IRouteGroup信息[IRouteGroup何时加载到Warehouse的,见下条],然后通过iGroupInstance.loadInto将改分组下的RouteMeta都加载到缓存中,这可以理解为延迟加载,降低初始化时的一些压力。加载后,再重新调用completion(postcard)。


4.IRouteGroup的加载

路由元数据RouteMeta是从实现了IRouteGroup接口的实例中load进来的,这个实现了IRouteGroup接口的类在哪?何时load进Warehouse?在LogisticsCenter.init()方法中,找到了踪迹。


public synchronized static void init(Context context, ThreadPoolExecutor tpe) throws HandlerException {
Set<String> routerMap;
// It will rebuild router map every times when debuggable.
if (ARouter.debuggable() || PackageUtils.isNewVersion(context)) {
// These class was generated by arouter-compiler.
routerMap = ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE);
if (!routerMap.isEmpty()) {
context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).edit().putStringSet(AROUTER_SP_KEY_MAP, routerMap).apply();
}

PackageUtils.updateVersion(context); // Save new version name when router map update finishes.
} else {
routerMap = new HashSet<>(context.getSharedPreferences(AROUTER_SP_CACHE_KEY, Context.MODE_PRIVATE).getStringSet(AROUTER_SP_KEY_MAP, new HashSet<String>()));
}

for (String className : routerMap) {
if (className.startsWith(ROUTE_ROOT_PAKCAGE + DOT + SDK_NAME + SEPARATOR + SUFFIX_ROOT)) {
// This one of root elements, load root.
((IRouteRoot) (Class.forName(className).getConstructor().newInstance())).loadInto(Warehouse.groupsIndex);
}
......
}
}

首次init时,通过ClassUtils.getFileNameByPackageName(mContext, ROUTE_ROOT_PAKCAGE)将ROUTE_ROOT_PAKCAGE = "com.alibaba.android.arouter.routes"下的所有类,都加载进routerMap中。然后通过区分routerMap类名,实例化com.alibaba.android.arouter.routes.ARouter##Root开头的类[由于csdn对$的支持并不友好,故以下$都使用#代替],调用其loadInto将对应的IRouteGroup类都加载到Warehouse.groupsIndex中。
PS:
init方法有一些小细节,针对debug版本或者新版本,才会有一次完整的类find和load的过程,加载完后会将类路径都存入sp,之后启动从sp拿,以增加启动速度。
ClassUtils.getFileNameByPackageName方法并不简单,其中牵扯了在多dex或者特殊rom下加载类的一些处理,有兴趣的同学可以阅读源码了解。


ARouter##Root##app


public class ARouter$$Root$$app implements IRouteRoot {
public ARouter$$Root$$app() {
}

public void loadInto(Map<String, Class<? extends IRouteGroup>> routes) {
routes.put("test", test.class);
}
}

ARouter##Group##test


public class ARouter$$Group$$test implements IRouteGroup {
public ARouter$$Group$$test() {
}

public void loadInto(Map<String, RouteMeta> atlas) {
atlas.put("/test/second", RouteMeta.build(RouteType.ACTIVITY, SecondActivity.class, "/test/second", "test", (Map)null, -1, -2147483648));
}
}

5.Route类的生成

接着上一步的解析,下面要了解的是,ARouter##Root##app,ARouter##Group##test这些编译好的类,是何时/如何生成的。这里使用的是android的apt(Annotation Processing Tool)技术,即在编译时,将注解生成为Java代码。所以在build.gradle添加依赖时,会添加注解处理器 annotationProcessor ‘com.alibaba:arouter-compiler:1.2.2’ ,具体的处理过程,可以参见arouter-compiler的RouteProcessor,RouteProcessor代码较长,这里就不详述了。感兴趣的童鞋,可以自己写一写注解处理器,com.squareup.javapoet神器了解一下。


资源下载:arouter-develop.zip

收起阅读 »

recycleview适配器,不看后悔到35岁

在我最近开发的一个Android项目当中,用到列表的地方非常多。用RecyclerView+BaseRecyclerViewAdapterHelper(开源框架)可以帮我们节省大量的代码(约节省三分之二),RecyclerView不用多说大家非常熟悉,谷歌推荐...
继续阅读 »


在我最近开发的一个Android项目当中,用到列表的地方非常多。用RecyclerView+BaseRecyclerViewAdapterHelper(开源框架)可以帮我们节省大量的代码(约节省三分之二),RecyclerView不用多说大家非常熟悉,谷歌推荐的列表控件,代替了传统的ListView,更加强大和灵活。BaseRecyclerViewAdapterHelper是一个非常强大的开源框架,它基本上可以解决我们开发中的列表布局。在这里记录一下这个框架。


框架引入


先在项目的 build.gradle中的 repositories 添加


allprojects {
repositories {
maven { url 'https://jitpack.io' }
}
}

然后在Module的 build.gradle中的 dependencies 添加


	dependencies {
implementation 'com.github.CymChad:BaseRecyclerViewAdapterHelper:2.9.47'
}

基本使用


首先我们在Activity中有一个RecyclerView



android:layout_width="match_parent"
android:layout_height="match_parent">

android:id="@+id/recycler"
android:layout_width="match_parent"
android:layout_height="match_parent"/>



再新建一个item布局,item布局是一个简单的头像和名字



android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="60dp"
android:layout_marginVertical="5dp">

android:id="@+id/iv_head"
android:layout_width="50dp"
android:layout_height="50dp"
android:layout_marginStart="10dp"
android:layout_gravity="center_vertical"
android:src="@mipmap/ic_launcher"/>

android:id="@+id/tv_name"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_marginStart="10dp"
android:layout_gravity="center_vertical"
android:text="张三"
android:textSize="18sp"
android:textColor="#000000"/>



再根据item所需数据,编写数据实体类型


public class User {
private String headUrl;
private String name;

public User(String headUrl, String name) {
this.headUrl = headUrl;
this.name = name;
}

public String getHeadUrl() {
return headUrl;
}

public void setHeadUrl(String headUrl) {
this.headUrl = headUrl;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}
}

接下来就要用到我们的BaseRecyclerViewAdapterHelper框架来编写适配器


public class UserAdapter extends BaseQuickAdapter {
public UserAdapter(int layoutResId, @Nullable List data) {
super(layoutResId, data);
}

@Override
protected void convert(BaseViewHolder helper, User item) {
Glide.with(mContext).load(item.getHeadUrl()).into((ImageView)helper.getView(R.id.iv_head));
helper.setText(R.id.tv_name, item.getName());
}
}

在这里我们用到图片加载框架,非常的好用,一行代码就可以加载url图片等,这里就不详细多说,GitHub地址:https://github.com/bumptech/glide


最后一步就是在我们的Activity使用该适配器


public class MainActivity extends AppCompatActivity {
private RecyclerView recycler;

private List userList;

private UserAdapter adapter;

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

recycler = findViewById(R.id.recycler);

//模拟数据,实际开发中一般是从后台获取数据
userList = new ArrayList<>();
for (int i = 0; i < 20; i++) {
userList.add(new User("http://img2.imgtn.bdimg.com/it/u=3749323882,846155126&fm=26&gp=0.jpg",
"第" + i + "条"));
}

//设置布局管理
recycler.setLayoutManager(new LinearLayoutManager(this));
//创建适配器
adapter = new UserAdapter(R.layout.item_recycler, userList);
//给RecyclerView设置适配器
recycler.setAdapter(adapter);
}
}

这样就是RecyclerView+BaseRecyclerViewAdapterHelper的基本使用,效果如下
在这里插入图片描述


点击事件


使用列表那当然也少不了点击事件,不论是整个item的点击事件还是item中的子控件都可以实现。


item的点击事件


		adapter.setOnItemClickListener(new BaseQuickAdapter.OnItemClickListener() {
@Override
public void onItemClick(BaseQuickAdapter adapter, View view, int position) {
Toast.makeText(MainActivity.this, "点击了第" + position + "条", Toast.LENGTH_SHORT).show();
}
});

item的长按事件


		adapter.setOnItemLongClickListener(new BaseQuickAdapter.OnItemLongClickListener() {
@Override
public boolean onItemLongClick(BaseQuickAdapter adapter, View view, int position) {
Toast.makeText(MainActivity.this, "长按了第" + position + "条", Toast.LENGTH_SHORT).show();
return false;
}
});

item中子控件的点击事件
首先在适配器中绑定子控件


public class UserAdapter extends BaseQuickAdapter {
public UserAdapter(int layoutResId, @Nullable List data) {
super(layoutResId, data);
}

@Override
protected void convert(BaseViewHolder helper, User item) {
Glide.with(mContext).load(item.getHeadUrl()).into((ImageView)helper.getView(R.id.iv_head));
helper.setText(R.id.tv_name, item.getName());
//绑定点击事件
helper.addOnClickListener(R.id.iv_head);
helper.addOnClickListener(R.id.tv_name);
}
}

接着在activity中就可以监听到子控件的点击事件,根据view.getId()来区分点击了哪一个子控件


		adapter.setOnItemChildClickListener(new BaseQuickAdapter.OnItemChildClickListener() {
@Override
public void onItemChildClick(BaseQuickAdapter adapter, View view, int position) {
switch (view.getId()) {
case R.id.iv_head:
Toast.makeText(MainActivity.this, "点击了第" + position + "的头像",
Toast.LENGTH_SHORT).show();
break;
case R.id.tv_name:
Toast.makeText(MainActivity.this, "点击了第" + position + "的名字",
Toast.LENGTH_SHORT).show();
break;
default:
break;
}
}
});

子控件的长按事件也是如此。


常用方法


上面介绍了基本的使用方法,还有很多常用的方法这里列举一下:



































方法名 说明
getData() 获取适配器中的数据
addData(data) 向列表中添加数据(可一条,可多条)
setData(position, data) 修改指定位置的数据
setNewData(List) 设置适配器新的数据
notifyDataSetChanged() 刷新适配器
remove(position) 删除指定数据

BaseRecyclerViewAdapterHelper还有很多其他功能,例如列表加载动画、下拉刷新、上拉加载、添加分组、自定义不同的item、拖拽item等,这里就不一一列举出来,有兴趣的可以去官方GitHub了解更多,地址如下:https://github.com/CymChad/BaseRecyclerViewAdapterHelper


资源下载:BaseRecyclerViewAdapterHelper-master (1).zip

收起阅读 »

Android开发者你好~你还在用dialog????

 https://github.com/li-xiaojun/XPopup/ 内置几种了常用的弹窗,十几种良好的动画,将弹窗和动画的自定义设计的极其简单;目前还没有出现XPopup实现不了的弹窗效果。 内置弹窗允许你使用项目已有的布局,同时还能...
继续阅读 »

 https://github.com/li-xiaojun/XPopup/



  • 内置几种了常用的弹窗,十几种良好的动画,将弹窗和动画的自定义设计的极其简单;目前还没有出现XPopup实现不了的弹窗效果。 内置弹窗允许你使用项目已有的布局,同时还能用上XPopup提供的动画,交互和逻辑封装。

  • UI动画简洁,遵循Material Design,在设计动画的时候考虑了很多细节,过渡,层级的变化

  • 交互优雅,实现了优雅的手势交互,智能的嵌套滚动,智能的输入法交互,具体看Demo

  • 适配全面屏,目前适配了小米,华为,谷歌,OPPO,VIVO,三星,魅族,一加全系全面屏手机

  • 自动监听Activity生命周期,自动释放资源。在Activity直接finish的场景也避免了内存泄漏

  • 很好的易用性,所有的自定义弹窗只需继承对应的类,实现你的布局,然后像Activity那样,在onCreate方法写逻辑即可

  • 性能优异,动画流畅;精心优化的动画,让你很难遇到卡顿场景

  • 能在应用后台弹出(需要申请悬浮窗权限,一行代码即可)

  • 支持androidx

  • 完美支持RTL布局

  • 如果你想要时间选择器和城市选择器,可以使用XPopup扩展功能库XPopupExt: https://github.com/li-xiaojun/XPopupExt

  • 设计思路: 综合常见的弹窗场景,我将其分为几类:


  • Center类型,就是在中间弹出的弹窗,比如确认和取消弹窗,Loading弹窗

  • Bottom类型,就是从页面底部弹出,比如从底部弹出的分享窗体,知乎的从底部弹出的评论列表,内部已经处理好手势拖拽和嵌套滚动

  • Attach类型,就是弹窗的位置需要依附于某个View或者某个触摸点,就像系统的PopupMenu效果一样,但PopupMenu的自定义性很差,淘宝的商品列表筛选的下拉弹窗,微信的朋友圈点赞弹窗都是这种。

  • Drawer类型,就是从窗体的坐边或者右边弹出,并支持手势拖拽;好处是与界面解耦,可以在任何界面实现DrawerLayout效果

  • ImageViewer大图浏览类型,就像掘金那样的图片浏览弹窗,带有良好的拖拽交互体验,内部嵌入了改良的PhotoView

  • FullScreen类型,全屏弹窗,看起来和Activity一样,可以设置任意的动画器;适合用来实现登录,选择性的界面效果。

  • Position自由定位弹窗,弹窗是自由的,你可放在屏幕左上角,右下角,或者任意地方,结合强大的动画器,可以实现各种效果。


 


implementation 'com.lxj:xpopup:2.0.0'

底部弹窗,自定义布局


new XPopup.Builder(this)
.asCustom(new RefundPopup(this, new RefundPopup.OnClickListener() {
@Override
public void clickConfirm() {
new XPopup.Builder(GoodsOrderDetailActivity.this)
.asCustom(new RefundReasonPopup(GoodsOrderDetailActivity.this, new RefundReasonPopup.OnClickListener() {
@Override
public void clickConfirm(String tag,String msg) {
getPresenter().applyRefund(goodsOrderId,tag,msg);
}
})).show();
}
})).show();

 



public class RefundPopup extends BottomPopupView {

private Context context;
private OnClickListener mOnClickListener;

public RefundPopup(@NonNull Context context) {
super(context);
this.context = context;
}

public RefundPopup(@NonNull Context context, OnClickListener onClickListener) {
super(context);
this.context = context;
mOnClickListener = onClickListener;
}

@Override
protected int getImplLayoutId() {
return R.layout.popup_refund;
}

protected int getPopupWidth() {
return AutoUtils.getPercentWidthSize(750);
}

@Override
protected void onCreate() {
super.onCreate();
ImageView ivBack = findViewById(R.id.ivBack);
TextView tvConfirm = findViewById(R.id.tvConfirm);
TextView tvCancel = findViewById(R.id.tvCancel);
ivBack.setOnClickListener(view -> {
dismiss();
});
tvCancel.setOnClickListener(view -> dismiss());
tvConfirm.setOnClickListener(view -> {
mOnClickListener.clickConfirm();
dismiss();
});
}

public interface OnClickListener {
void clickConfirm();
}

}

资源下载:xpopup-master.zip


收起阅读 »

快来为你的照片添加个性标签吧!

1. 前言 PS:最近在项目执行过程中有这样一个需求,要求拍完照的图片必须达到以上的效果。需求分析: 使用用预览布局SurfaceView,在不局上方使用控件的方式来进行设计,最后通过截图的方式将画面进行保存。 使用图片添加水印的方式来完成。 ...
继续阅读 »

1. 前言


需求图.png


PS:最近在项目执行过程中有这样一个需求,要求拍完照的图片必须达到以上的效果。需求分析:




  1. 使用用预览布局SurfaceView,在不局上方使用控件的方式来进行设计,最后通过截图的方式将画面进行保存。




  2. 使用图片添加水印的方式来完成。




2. 方法1 使用SurfaceView


我心想这不简单吗?于是开始一顿balabala的操作,结果到最后一步时发现,SurfaceView居然不能进行截图,截图下来的图片居然是一张黑色的。简单地说这是因为SurfaceView的特性决定的,我们知道安卓中唯一可以在子线程中进行绘制的view就只有Surfaceview了。他可以独立于子线程中绘制,不会导致主线程的卡顿,至于造成surfaceView黑屏的原因,可以移步这里
Android视图SurfaceView的实现原理分析。如果非要使用此方式时还是有三种思路来进行解决:
采用三种思路:


1. 获取源头视频的截图作为SurfaceView的截图
2. 获取SurfaceView的画布canvas,将canvas保存成Bitmap
3. 直接截取整个屏幕,然后在截图SurfaceView位置的图
复制代码

但是我觉得这种方式太过繁琐,所以选择用添加水印的式来完成。


3. 方法2 给拍照下来的图片添加水印


第一步:获取拍照权限


<!--相机权限-->
<uses-permission android:name="android.permission.CAMERA" />
<!--访问外部权限-->
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
复制代码

这里使用到郭霖大佬的开源库PermissionX获取权限:


PermissionX.init(this)
.permissions(Manifest.permission.CAMERA, Manifest.permission.RECORD_AUDIO)
.onExplainRequestReason { scope, deniedList ->
val message = "需要您同意以下权限才能正常使用"
scope.showRequestReasonDialog(deniedList, message, "确定", "取消")
}
.request { allGranted, grantedList, deniedList ->
if (allGranted) {
openCamera()
} else {
Toast.makeText(activity, "您拒绝了如下权限:$deniedList", Toast.LENGTH_SHORT).show()
}
}
复制代码

第二步:拍照


android 6.0以后,相机权限需要动态申请。


 // 申请相机权限的requestCode
private static final int PERMISSION_CAMERA_REQUEST_CODE = 0x00000012;

/**
* 检查权限并拍照。
* 调用相机前先检查权限。
*/
private void checkPermissionAndCamera() {
int hasCameraPermission = ContextCompat.checkSelfPermission(getApplication(),
Manifest.permission.CAMERA);
if (hasCameraPermission == PackageManager.PERMISSION_GRANTED) {
//有调起相机拍照。
openCamera();
} else {
//没有权限,申请权限。
ActivityCompat.requestPermissions(this,new String[]{Manifest.permission.CAMERA},
PERMISSION_CAMERA_REQUEST_CODE);
}
}

/**
* 处理权限申请的回调。
*/
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
if (requestCode == PERMISSION_CAMERA_REQUEST_CODE) {
if (grantResults.length > 0
&& grantResults[0] == PackageManager.PERMISSION_GRANTED) {
//允许权限,有调起相机拍照。
openCamera();
} else {
//拒绝权限,弹出提示框。
Toast.makeText(this,"拍照权限被拒绝",Toast.LENGTH_LONG).show();
}
}
}
复制代码

调用相机进行拍照


申请权限后,就可以调起相机拍照了。调用相机只需要调用startActivityForResult传一个Intent就可以了,但是这个Intent需要传递一个uri,用于保存拍出来的图片,创建这个uri时,各个Android版本有所不同,需要进行版本兼容。


  //用于保存拍照图片的uri
private Uri mCameraUri;

// 用于保存图片的文件路径,Android 10以下使用图片路径访问图片
private String mCameraImagePath;

// 是否是Android 10以上手机
private boolean isAndroidQ = Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.Q;

/**
* 调起相机拍照
*/
private void openCamera() {
Intent captureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
// 判断是否有相机
if (captureIntent.resolveActivity(getPackageManager()) != null) {
File photoFile = null;
Uri photoUri = null;

if (isAndroidQ) {
// 适配android 10
photoUri = createImageUri();
} else {
try {
photoFile = createImageFile();
} catch (IOException e) {
e.printStackTrace();
}

if (photoFile != null) {
mCameraImagePath = photoFile.getAbsolutePath();
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
//适配Android 7.0文件权限,通过FileProvider创建一个content类型的Uri
photoUri = FileProvider.getUriForFile(this, getPackageName() + ".fileprovider", photoFile);
} else {
photoUri = Uri.fromFile(photoFile);
}
}
}

mCameraUri = photoUri;
if (photoUri != null) {
captureIntent.putExtra(MediaStore.EXTRA_OUTPUT, photoUri);
captureIntent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);
startActivityForResult(captureIntent, CAMERA_REQUEST_CODE);
}
}
}

/**
* 创建图片地址uri,用于保存拍照后的照片 Android 10以后使用这种方法
*/
private Uri createImageUri() {
String status = Environment.getExternalStorageState();
// 判断是否有SD卡,优先使用SD卡存储,当没有SD卡时使用手机存储
if (status.equals(Environment.MEDIA_MOUNTED)) {
return getContentResolver().insert(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, new ContentValues());
} else {
return getContentResolver().insert(MediaStore.Images.Media.INTERNAL_CONTENT_URI, new ContentValues());
}
}

/**
* 创建保存图片的文件
*/
private File createImageFile() throws IOException {
String imageName = new SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(new Date());
File storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES);
if (!storageDir.exists()) {
storageDir.mkdir();
}
File tempFile = new File(storageDir, imageName);
if (!Environment.MEDIA_MOUNTED.equals(EnvironmentCompat.getStorageState(tempFile))) {
return null;
}
return tempFile;
}
复制代码

接收拍照结果


  @Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == CAMERA_REQUEST_CODE) {
if (resultCode == RESULT_OK) {
if (isAndroidQ) {
// Android 10 使用图片uri加载
ivPhoto.setImageURI(mCameraUri);
} else {
// 使用图片路径加载
ivPhoto.setImageBitmap(BitmapFactory.decodeFile(mCameraImagePath));
}
} else {
Toast.makeText(this,"取消",Toast.LENGTH_LONG).show();
}
}
}
复制代码

注意:


这两需要说明一下,Android 10由于文件权限的关系,显示手机储存卡里的图片不能直接使用图片路径,需要使用图片uri加载。


另外虽然我在这里对Android 10和10以下的手机使用了不同的方式创建uri 和加载图片,但其实Android 10创建uri的方式和使用uri加载图片的方式在10以下的手机是同样适用的。
android 7.0需要配置文件共享。


<provider
android:name="androidx.core.content.FileProvider"
android:authorities="${applicationId}.fileprovider"
android:exported="false"
android:grantUriPermissions="true">
<meta-data
android:name="android.support.FILE_PROVIDER_PATHS"
android:resource="@xml/file_paths" />
</provider>
复制代码

在res目录下创建文件夹xml ,放置一个文件file_paths.xml(文件名可以随便取),配置需要共享的文件目录,也就是拍照图片保存的目录。


<?xml version="1.0" encoding="utf-8"?>
<resources>
<paths>
<!-- 这个是保存拍照图片的路径,必须配置。 -->
<external-files-path
name="images"
path="Pictures" />
</paths>
</resources>
复制代码

第三步:给拍照后得到的图片添加水印


  @Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
super.onActivityResult(requestCode, resultCode, data);
if (requestCode == CAMERA_REQUEST_CODE) {
if (resultCode == RESULT_OK) {
Bitmap mp;
if (isAndroidQ) {
// Android 10 使用图片uri加载
mp = MediaStore.Images.Media.getBitmap(this.contentResolver, t.uri);
} else {
// Android 10 以下使用图片路径加载
mp = BitmapFactory.decodeFile(uri);
}
//对图片添加水印 这里添加一张图片为示例:
ImageUtil.drawTextToLeftTop(this,mp,"示例文字",30,R.color.black,20,30)
} else {
Toast.makeText(this,"取消",Toast.LENGTH_LONG).show();
}
}
}
复制代码

这里使用到一个ImageUtil工具类,我在这里贴上。如果需要使用可以直接拿走~


public class ImageUtil {
/**
* 设置水印图片在左上角
*
* @param context 上下文
* @param src
* @param watermark
* @param paddingLeft
* @param paddingTop
* @return
*/
public static Bitmap createWaterMaskLeftTop(Context context, Bitmap src, Bitmap watermark, int paddingLeft, int paddingTop) {
return createWaterMaskBitmap(src, watermark,
dp2px(context, paddingLeft), dp2px(context, paddingTop));
}

private static Bitmap createWaterMaskBitmap(Bitmap src, Bitmap watermark, int paddingLeft, int paddingTop) {
if (src == null) {
return null;
}
int width = src.getWidth();
int height = src.getHeight();
//创建一个bitmap
Bitmap newb = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);// 创建一个新的和SRC长度宽度一样的位图
//将该图片作为画布
Canvas canvas = new Canvas(newb);
//在画布 0,0坐标上开始绘制原始图片
canvas.drawBitmap(src, 0, 0, null);
//在画布上绘制水印图片
canvas.drawBitmap(watermark, paddingLeft, paddingTop, null);
// 保存
canvas.save(Canvas.ALL_SAVE_FLAG);
// 存储
canvas.restore();
return newb;
}

/**
* 设置水印图片在右下角
*
* @param context 上下文
* @param src
* @param watermark
* @param paddingRight
* @param paddingBottom
* @return
*/
public static Bitmap createWaterMaskRightBottom(Context context, Bitmap src, Bitmap watermark, int paddingRight, int paddingBottom) {
return createWaterMaskBitmap(src, watermark,
src.getWidth() - watermark.getWidth() - dp2px(context, paddingRight),
src.getHeight() - watermark.getHeight() - dp2px(context, paddingBottom));
}

/**
* 设置水印图片到右上角
*
* @param context
* @param src
* @param watermark
* @param paddingRight
* @param paddingTop
* @return
*/
public static Bitmap createWaterMaskRightTop(Context context, Bitmap src, Bitmap watermark, int paddingRight, int paddingTop) {
return createWaterMaskBitmap(src, watermark,
src.getWidth() - watermark.getWidth() - dp2px(context, paddingRight),
dp2px(context, paddingTop));
}

/**
* 设置水印图片到左下角
*
* @param context
* @param src
* @param watermark
* @param paddingLeft
* @param paddingBottom
* @return
*/
public static Bitmap createWaterMaskLeftBottom(Context context, Bitmap src, Bitmap watermark, int paddingLeft, int paddingBottom) {
return createWaterMaskBitmap(src, watermark, dp2px(context, paddingLeft),
src.getHeight() - watermark.getHeight() - dp2px(context, paddingBottom));
}

/**
* 设置水印图片到中间
*
* @param src
* @param watermark
* @return
*/
public static Bitmap createWaterMaskCenter(Bitmap src, Bitmap watermark) {
return createWaterMaskBitmap(src, watermark,
(src.getWidth() - watermark.getWidth()) / 2,
(src.getHeight() - watermark.getHeight()) / 2);
}

/**
* 给图片添加文字到左上角
*
* @param context
* @param bitmap
* @param text
* @return
*/
public static Bitmap drawTextToLeftTop(Context context, Bitmap bitmap, String text, int size, int color, int paddingLeft, int paddingTop) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(color);
paint.setTextSize(dp2px(context, size));
Rect bounds = new Rect();
paint.getTextBounds(text, 0, text.length(), bounds);
return drawTextToBitmap(context, bitmap, text, paint, bounds,
dp2px(context, paddingLeft),
dp2px(context, paddingTop) + bounds.height());
}

/**
* 绘制文字到右下角
*
* @param context
* @param bitmap
* @param text
* @param size
* @param color
* @return
*/
public static Bitmap drawTextToRightBottom(Context context, Bitmap bitmap, String text, int size, int color, int paddingRight, int paddingBottom) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(color);
paint.setTextSize(dp2px(context, size));
Rect bounds = new Rect();
paint.getTextBounds(text, 0, text.length(), bounds);
return drawTextToBitmap(context, bitmap, text, paint, bounds,
bitmap.getWidth() - bounds.width() - dp2px(context, paddingRight),
bitmap.getHeight() - dp2px(context, paddingBottom));
}

/**
* 绘制文字到右上方
*
* @param context
* @param bitmap
* @param text
* @param size
* @param color
* @param paddingRight
* @param paddingTop
* @return
*/
public static Bitmap drawTextToRightTop(Context context, Bitmap bitmap, String text, int size, int color, int paddingRight, int paddingTop) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(color);
paint.setTextSize(dp2px(context, size));
Rect bounds = new Rect();
paint.getTextBounds(text, 0, text.length(), bounds);
return drawTextToBitmap(context, bitmap, text, paint, bounds,
bitmap.getWidth() - bounds.width() - dp2px(context, paddingRight),
dp2px(context, paddingTop) + bounds.height());
}

/**
* 绘制文字到左下方
*
* @param context
* @param bitmap
* @param text
* @param size
* @param color
* @param paddingLeft
* @param paddingBottom
* @return
*/
public static Bitmap drawTextToLeftBottom(Context context, Bitmap bitmap, String text, int size, int color, int paddingLeft, int paddingBottom) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(color);
paint.setTextSize(dp2px(context, size));
Rect bounds = new Rect();
paint.getTextBounds(text, 0, text.length(), bounds);
return drawTextToBitmap(context, bitmap, text, paint, bounds,
dp2px(context, paddingLeft),
bitmap.getHeight() - dp2px(context, paddingBottom));
}

/**
* 绘制文字到中间
*
* @param context
* @param bitmap
* @param text
* @param size
* @param color
* @return
*/
public static Bitmap drawTextToCenter(Context context, Bitmap bitmap, String text, int size, int color) {
Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
paint.setColor(color);
paint.setTextSize(dp2px(context, size));
Rect bounds = new Rect();
paint.getTextBounds(text, 0, text.length(), bounds);
return drawTextToBitmap(context, bitmap, text, paint, bounds,
(bitmap.getWidth() - bounds.width()) / 2,
(bitmap.getHeight() + bounds.height()) / 2);
}

//图片上绘制文字
private static Bitmap drawTextToBitmap(Context context, Bitmap bitmap, String text, Paint paint, Rect bounds, int paddingLeft, int paddingTop) {
android.graphics.Bitmap.Config bitmapConfig = bitmap.getConfig();

paint.setDither(true); // 获取跟清晰的图像采样
paint.setFilterBitmap(true);// 过滤一些
if (bitmapConfig == null) {
bitmapConfig = android.graphics.Bitmap.Config.ARGB_8888;
}
bitmap = bitmap.copy(bitmapConfig, true);
Canvas canvas = new Canvas(bitmap);

canvas.drawText(text, paddingLeft, paddingTop, paint);
return bitmap;
}

/**
* 缩放图片
*
* @param src
* @param w
* @param h
* @return
*/
public static Bitmap scaleWithWH(Bitmap src, double w, double h) {
if (w == 0 || h == 0 || src == null) {
return src;
} else {
// 记录src的宽高
int width = src.getWidth();
int height = src.getHeight();
// 创建一个matrix容器
Matrix matrix = new Matrix();
// 计算缩放比例
float scaleWidth = (float) (w / width);
float scaleHeight = (float) (h / height);
// 开始缩放
matrix.postScale(scaleWidth, scaleHeight);
// 创建缩放后的图片
return Bitmap.createBitmap(src, 0, 0, width, height, matrix, true);
}
}

/**
* dip转pix
*
* @param context
* @param dp
* @return
*/
public static int dp2px(Context context, float dp) {
final float scale = context.getResources().getDisplayMetrics().density;
return (int) (dp * scale + 0.5f);
}
}

复制代码

4. 最终实现的效果如下:


效果.jpg


5.总结


整体来说没有什么太大的问题,添加水印的原理就是通过Canvas绘制的方式将文字/图片添加到图片上。最后再将修改之后的图片呈现给用户。同时也记录下SurfaceView截图黑屏的问题。


作者:LiChengZe_Blog
链接:https://juejin.cn/post/6960579316191068197
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

收起阅读 »

数据时代之非侵入式埋点方案

在发展日新月异的移动互联网时代,数据扮演着极其重要的角色。埋点作为一种最简单最直接的用户行为统计方式,能够全面精确的采集用户的使用习惯以及各功能点的迭代反馈等等,有了这些数据才能更好的驱动产品的决策设计和新业务场景的规划。本文旨在提出一种轻量级非侵入式的埋点方...
继续阅读 »

在发展日新月异的移动互联网时代,数据扮演着极其重要的角色。埋点作为一种最简单最直接的用户行为统计方式,能够全面精确的采集用户的使用习惯以及各功能点的迭代反馈等等,有了这些数据才能更好的驱动产品的决策设计和新业务场景的规划。本文旨在提出一种轻量级非侵入式的埋点方案,其主要有以下三方面优势

  • 支持动态下发埋点配置

  • 物理隔离埋点代码和业务代码

  • 插件式的埋点功能实现

该方案通过维护一个JSON文件来指定埋点所在的类和方法,继而利用AOP的方式在对应的类和方法执行时动态嵌入埋点代码。对于需要逻辑判断来确定埋点值的场景,提供hook方法的入参,以及所在类的属性值读取,根据相应的状态值设置不同的埋点

埋点配置

埋点配置JSON表中包含需要hook的类名class和具体的事件event信息,event中包括hook的方法和对应的埋点值。如下所示

{
"version": "0.1.0",
"tracking": [
{
"class": "RJMainViewController",
"event": {
"rj_main_tracking": [
"tripTypeViewChangedWithIndex:",
"tripLabClickWithLabKey:"
],
"user_fp_slide_click": "clickNavLeftBtn",
"user_fp_reflocate_click": "clickLocationBtn"
}
},
{
"class": "RJTripHistoryViewModel",
"event": {
"user_mytrip_show": "tableView:didSelectRowAtIndexPath:"
}
},
{
"class": "RJTripViewController",
"event": {
"rj_trip_tracking": "callServiceEvent"
}
}
]
}

简单来说就是本来埋点需要手动在该方法写入埋点代码来记录埋点值,现在通过AOP的方式物理隔离埋点代码和业务代码,避免埋点的逻辑侵入污染业务逻辑。埋点包括固定埋点和需要逻辑判断的场景化埋点,固定埋点如下所示

{
"class": "RJTripHistoryViewModel",
"event": {
"user_mytrip_show": "tableView:didSelectRowAtIndexPath:"
}
}

RJTripHistoryViewModel为类名,tableView:didSelectRowAtIndexPath:为需要hook的该类中的方法,而user_mytrip_show则是具体的埋点值,也就是当RJTripHistoryViewModel中的tableView:didSelectRowAtIndexPath:方法执行的时候记录埋点值user_mytrip_show

{
"class": "RJTripViewController",
"event": {
"rj_trip_tracking": "callServiceEvent"
}
},

对于场景化埋点,则需要提供一个impl类来提供相应的逻辑判断。比如上述配置表中的rj_trip_tracking为场景埋点的实现类,在该类中根据状态量返回对应的埋点值,即当callServiceEvent方法执行时会去找rj_trip_tracking这个埋点impl同名类,取该类返回的埋点值记录埋点。需要注意到是event中的key值既可以作为埋点值也可以作为impl的类名,埋点库会首先判断是否存在对应的类,存在即认为是impl实现类,从该类中取具体的埋点值。反之,则认为是固定埋点值

配置表中的类名和方法名需要对应,在hook的时候会去匹配,如果发现类中不存在对应的方法,则会自动触发断言

固定埋点

对于固定的埋点,只需要在对应的方法执行时直接记录埋点,利用Aspects来hook指定的类和方法,代码如下所示

[class aspect_hookSelector:sel withOptions:AspectPositionBefore usingBlock:^(id<AspectInfo> info) {
[events enumerateObjectsUsingBlock:^(NSString *name, NSUInteger idx, BOOL *stop) {
NSLog(@"<RJEventTracking> - %@", ename);
}];
} error:&error];

为了便于检测无效的埋点,还需对hook的类和方法进行匹配校验,若类中没有对应的方法,则抛出断言

+ (void)checkValidWithClass:(NSString *)class method:(NSString *)method {
SEL sel = NSSelectorFromString(method);
Class c = NSClassFromString(class);
BOOL respond = [c respondsToSelector:sel] || [c instancesRespondToSelector:sel];
NSString *err = [NSString stringWithFormat:@"<RJEventTracking> - no specified method: %@ found on class: %@, please check", method, class];

NSAssert(respond, err);
}

场景埋点

场景化埋点主要为同一事件但是在多种状态或逻辑下不同埋点的情况,比如同是联系客服的操作,在各种订单类型以及订单状态下所设置的埋点是不同的。这个情况下,埋点库通过提供一个protocol由埋点impl类来实现,根据不同的逻辑判断,返回对应的埋点值

@protocol RJEventTracking <NSObject>

- (NSString *)trackingMethod:(NSString *)method instance:(id)instance arguments:(NSArray *)arguments;

@end

比如上文的rj_trip_tracking类需要遵循RJEventTracking协议,并根据相关逻辑判断返回对应的埋点值

埋点实现类的类名需要与埋点配置JSON中的event里的key保持一致,因为埋点库会通过检测是否有同名的类来实现插件式的埋点规则。另外,一个impl可以对应多个method方法

状态判断

根据状态量来确定埋点值。还是联系客服埋点的例子,根据订单种类和订单状态来返回对应的埋点值,首先定义JSON表中同名的impl类,并遵循RJEventTracking协议

#import "RJEventTracking.h"

NS_ASSUME_NONNULL_BEGIN

@interface rj_trip_tracking : NSObject <RJEventTracking>

@end

NS_ASSUME_NONNULL_END

在.m文件中实现自定义埋点的协议方法trackingMethod:instance:arguments:

#import "rj_trip_tracking.h"

@implementation rj_trip_tracking

- (NSString *)trackingMethod:(NSString *)method instance:(id)instance arguments:(NSArray *)arguments {
id dataManager = [instance property:@"dataManager"];
NSInteger orderStatus = [[dataManager property:@"orderStatus"] integerValue];
NSInteger orderType = [[dataManager property:@"orderType"] integerValue];

if ([method isEqualToString:@"callServiceEvent"]) {
if (orderType == 1) {
if (orderStatus == 1) {
return @"user_inbook_psgservice_click";
} else if (orderStatus == 2) {
return @"user_finishbook_psgservice_click";
}
} else {
return @"user_psgservice_click";
}
}
return nil;
}

@end

在协议方法中,可以获取当前的实例(在这个示例下为RJTripViewController)和入参数组。订单的类型和状态是存储在RJTripViewController中的dataManager属性中的,所以可以通过埋点库封装好的property:方法来获取属性值,并根据属性值返回对应的埋点名称

@interface NSObject (RJEventTracking)

- (id)property:(NSString *)property;

@end

属性值读取的实现为

- (id)property:(NSString *)property {
return [NSObject runMethodWithObject:self selector:property arguments:nil];
}

其中的原理很简单,就是将getter方法封装到NSInvocation中并invoke读取返回值即可

+ (id)runMethodWithObject:(id)object selector:(NSString *)selector arguments:(NSArray *)arguments {
if (!object) return nil;

if (arguments && [arguments isKindOfClass:NSArray.class] == NO) {
arguments = @[arguments];
}
SEL sel = NSSelectorFromString(selector);

NSMethodSignature *signature = [object methodSignatureForSelector:sel];
if (!signature) {
return nil;
}
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
invocation.selector = sel;
invocation.arguments = arguments;
[invocation invokeWithTarget:object];

return invocation.returnValue_obj;
}

入参判断

需要根据JSON中设置的所hook方法的入参来确定埋点名称的情况。比如在订单列表中点击全部,进行中,待支付,待评价,已完成等菜单项时分别埋点。被hook的方法为tripLabClickWithLabKey:其参数为UILabel,原先代码中通过Label的tag判断是点击的哪个子项,同样,我们也可以获取到Label的入参然后据此判断。由于参数只有一个,所以可以直接取arguments第一个值

#import "rj_main_tracking.h"
#import <UIKit/UIKit.h>

static NSString *order_types[5] = { @"user_order_all_click", @"user_order_ongoing_click",
@"user_order_unpay_click", @"user_order_unmark_click",
@"user_order_finish_click" };
@implementation rj_main_tracking

- (NSString *)trackingMethod:(NSString *)method instance:(id)instance arguments:(NSArray *)arguments {
if ([method isEqualToString:@"tripLabClickWithLabKey:"]) {
UILabel *label = arguments[0];
if (!label || label.tag > 4) {
return nil;
}
return order_types[label.tag];
} else if ([method isEqualToString:@"tripTypeViewChangedWithIndex:"]) {
return @"xx_ryan_jin";
}
}

@end

通过AOP来hook方法时,可以获取到当前hook方法所对应的实例对象和入参,在调用协议方法时,直接传给协议实现类

方法调用

和读取属性值类似,也是在不同场景下同一事件不同埋点名称的情况,但获取的状态量不是当前实例对象的,而是某个方法的返回值,这种情况下可以通过埋点库提供的方法调用函数来实现

@interface NSObject (RJEventTracking)

- (id)performSelector:(NSString *)selector arguments:(nullable NSArray *)arguments;

@end

比如获取某个页面的视图类型,而这个视图类型存储于单例对象中

[RJViewTypeModel sharedInstance].viewType

该场景下则根据viewType的类型,来返回相应的埋点名称

- (NSString *)trackingMethod:(NSString *)method instance:(id)instance arguments:(NSArray *)arguments {
NSString *labKey = [instance property:@"labKey"];
id viewTypeModel = [NSClassFromString(@"RJViewTypeModel") performSelector:@"sharedInstance"
arguments:nil];
NSInteger viewType = [[viewTypeModel property:@"viewType"] integerValue];

if (viewType == 0) {
if ([labKey isEqualToString:@"rj_view_begin_add"]) {
return @"user_fp_book_on_click";
}
if ([labKey isEqualToString:@"rj_view_end_add"]) {
return @"user_fp_book_off_click";
}
}
if (viewType == 1) {
if ([labKey isEqualToString:@"rj_view_begin_add"]) {
return @"user_fr_on_click";
}
if ([labKey isEqualToString:@"rj_view_end_add"]) {
return @"user_fr_off_click";
}
}
return nil;
}

逻辑判断

需要额外添加逻辑判断的场景,比如在订单详情页需要统计用户进入页面的查看行为,但是详情页的类型需要在网络请求后才能获取,而且该网络请求会定时触发,所以埋点hook的方法会走多次,该情况下,需要添加一个属性用来标记是否已记录埋点 。故而埋点库需要提供动态添加属性的功能

@interface NSObject (RJEventTracking)

- (id)extraProperty:(NSString *)property;

- (void)addExtraProperty:(NSString *)property defaultValue:(id)value;

@end

在埋点实现impl类里面,添加额外的属性来标记是否已记录过埋点

@implementation user_orderdetail_show

- (NSString *)trackingMethod:(NSString *)method instance:(id)instance arguments:(NSArray *)arguments {
if ([instance extraProperty:@"isRecorded"]) {
return nil;
}
[instance addExtraProperty:@"isRecorded" defaultValue:@(YES)];

return @"user_orderdetail_show";
}

@end

使用addExtraProperty:defaultValue:来给当前实例动态添加属性,而extraProperty:方法则用来获取实例的某个额外属性。如果isRecorded返回YES代表已经记录过该埋点,返回nil值来忽略该次埋点

上面示例中添加的isRecorded属性是因为埋点的需求,和业务逻辑无关,所以比较合理的方式是在埋点的插件impl类中添加,避免影响业务代码

埋点库动态添加属性的原理也很简单,利用runtime的objc_setAssociatedObject和objc_getAssociatedObject方法来绑定属性到实例对象

- (id)extraProperty:(NSString *)property {
return objc_getAssociatedObject(self, NSSelectorFromString(property));
}

- (void)addExtraProperty:(NSString *)property defaultValue:(id)value {
objc_setAssociatedObject(self, NSSelectorFromString(property), value, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

动态下发

埋点JSON配置表可以由服务器提供接口,客户端在每次启动时通过接口获取最新埋点配置表,从而达到动态下发的目的,客户端拿到JSON后,读取埋点信息并生效

[RJEventTracking loadConfiguration:[[NSBundle mainBundle] pathForResource:@"RJUserTracking" ofType:@"json"]];

读取的代码如下所示,主要逻辑为遍历埋点中的类和hook的方法,并检测是固定埋点还是场景化埋点,对于场景化埋点的情况查询是否有对应的埋点impl实现类。当然,还需检测JSON配置表的合法性,每个类和其中的方法是否匹配

+ (void)loadConfiguration:(NSString *)path {
NSData *data = [NSData dataWithContentsOfFile:path];
if (!data) {
return;
}
NSDictionary *dict = [NSJSONSerialization JSONObjectWithData:data options:NSJSONReadingMutableLeaves error:nil];
NSString *version = dict[@"version"];
NSArray *ts = dict[@"tracking"];
[ts enumerateObjectsUsingBlock:^(NSDictionary *obj, NSUInteger idx, BOOL *stop) {
Class class = NSClassFromString(obj[@"class"]);
NSDictionary *ed = obj[@"event"];
NSMutableDictionary *td = [NSMutableDictionary dictionaryWithCapacity:0];
[ed enumerateKeysAndObjectsUsingBlock:^(NSString *key, id obj, BOOL *stop) {
NSMutableArray *tArr = [NSMutableArray arrayWithCapacity:0];
[tArr addObjectsFromArray:[obj isKindOfClass:[NSArray class]] ? obj : @[obj]];
[tArr enumerateObjectsUsingBlock:^(NSString *m, NSUInteger idx, BOOL *stop) {
if ([td.allKeys containsObject:m]) {
NSMutableArray *ms = [td[m] mutableCopy];
if (![ms containsObject:key]) [ms addObject:key];
td[m] = ms;
} else {
td[m] = @[key];
}
}];
}];
[td enumerateKeysAndObjectsUsingBlock:^(NSString *kmethod, NSArray <NSString *> *tArr, BOOL *stop) {
SEL sel = NSSelectorFromString(kmethod);
NSError *error = nil;
[self checkValidWithClass:obj[@"class"] method:kmethod];
[class aspect_hookSelector:sel withOptions:AspectPositionBefore usingBlock:^(id<AspectInfo> info) {
[tArr enumerateObjectsUsingBlock:^(NSString *name, NSUInteger idx, BOOL *stop) {
NSString *ename = name;
id<RJEventTracking> t = [NSClassFromString(name) new];
if (t && [t respondsToSelector:@selector(trackingMethod:instance:arguments:)]) {
ename = [t trackingMethod:kmethod instance:info.instance
arguments:info.arguments];
}
if ([ename length]) {
NSLog(@"<RJEventTracking> - %@", ename);
}
}];
} error:&error];
[self checkHookStatusWithClass:obj[@"class"] method:kmethod error:error];
}];
}];
}

最后附上源码地址: https://github.com/rjinxx/RJEventTracking,

pod 'RJEventTracking'

在使用RJEventTracking的过程中中有遇到什么问题或者优化建议欢迎留言PR,谢谢。

转自:https://www.jianshu.com/p/cdf61602316e

收起阅读 »

iOS仿高德路线规划滑动效果

因为项目有个界面要模仿高德地图路径规划滑动效果,因此写了demo,并简单说下分析过程高德地图效果演示:demo效果演示:Demo地址:https://github.com/fangjinfeng/MySampleCode/tree/master/FJFBlog...
继续阅读 »

因为项目有个界面要模仿高德地图路径规划滑动效果,因此写了demo,并简单说下分析过程

高德地图效果演示:


demo效果演示:


Demo地址:https://github.com/fangjinfeng/MySampleCode/tree/master/FJFBlogProjectDemo

一. 分析

  • 首先,我们可以看出这个滚动的视图应该是UIScrollView或者UIScrollView的子类(比如:UITableView);

  • 其次,从高德地图里的视图一开始的滑动,可以看出这个滑动是平稳的滑动,没有加速和减速,因此这里不可能是UIScrollView的滚动效果,因为UIScrollView的滚动效果是由一个加减速的过程,因此一开始滑动,应该是通过滑动手势UIPanGestureRecognizer,来移动UIScrollView的y值来移动

  • 接着滑动到指定位置之后,UIScrollView的y值固定不动,然后UIScrollView的内容进行滚动。这里就涉及到滑动手势UIPanGestureRecognizer的滑动,还有UIScrollView内部的滚动的处理。高德地图的演示效果里面,一开始滑动视图向上移动,移动到指定的点之后,立马就变成视图的滚动,这里可以分析,UIScrollView既支持手势的滑动又支持视图的滚动,只是通过条件来判断限制两者的执行逻辑。

  • 同时我们可以看到,如果一开始向上拉动视图力度大一点,视图会直接滚动到指定位置,如果力度小,就恢复到原来位置,因此这里需要依据手势滑动的加速度来进行判断处理。

  • 而当你滑动到中间位置的时候,也需要依据最后滑动的位置来判断应该动画滚动到上方还是下方。

  • 最后滑动的时候上方的视图和滑动视图本身有背景颜色的渐变效果,这里需要依据滑动距离来判断。

二.代码分析:

首先由于滚动视图(demo里面是UITableView)需要支持手势滑动和内部滚动,因此需要写一个类FJBaseTableView继承自UITableView,然后在FJBaseTableView的实现里面重写如下方法:

// 当有 多个手势 都可以 响应
- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer shouldRecognizeSimultaneouslyWithGestureRecognizer:(UIGestureRecognizer *)otherGestureRecognizer {

return YES;
}

来支持响应多个手势。

  • 然后给滚动视图tableView添加滑动手势,当tableView从底部滑动到顶部指定位置时,应该限制tableView内部的视图滚动。

- (void)scrollViewDidScroll:(UIScrollView *)scrollView {
if (self.tableView.frame.origin.y > _scrollViewStartPositionY) {
[scrollView setContentOffset:CGPointMake(0, 0)];
}
}

这里的_scrollViewStartPositionY是顶部指定位置。

  • 接着看下手势滑动的处理逻辑:

#pragma mark - 手势处理
- (void)handlePanGesture:(UIPanGestureRecognizer *)sender {

if (sender.state == UIGestureRecognizerStateBegan) {

_beganPoint = [sender locationInView:sender.view.superview];
_curPoint = sender.view.center;
_topTipContainerViewCurrentY = _topContainerView.frame.origin.y;
_previousOffsetY = self.tableView.contentOffset.y;

} else if(sender.state == UIGestureRecognizerStateChanged) {

CGPoint point = [sender locationInView:sender.view.superview];

CGFloat offsetY = _previousOffsetY - self.tableView.contentOffset.y;
NSInteger y_offset = point.y - _beganPoint.y - offsetY;

if (sender.view.frame.origin.y >= _scrollViewStartPositionY || (self.tableView.contentOffset.y == 0 && self.tableView.contentSize.height > self.tableView.frame.size.height)) {
sender.view.center = CGPointMake(_curPoint.x, _curPoint.y + y_offset);
[self updateViewControlsWithSlideOffset:y_offset];
}

if (sender.view.frame.origin.y > _scrollViewLimitMaxY) {
sender.view.y = _scrollViewLimitMaxY;
[self updateViewControlsWithSlideUp:NO];
}
else if(sender.view.frame.origin.y < _scrollViewStartPositionY) {

sender.view.y = _scrollViewStartPositionY;
[self updateViewControlsWithSlideUp:YES];
}
} else if(sender.state == UIGestureRecognizerStateEnded) {

if (sender.view.frame.origin.y <= _scrollViewStartPositionY || sender.view.frame.origin.y > _scrollViewLimitMaxY) {
if (sender.view.frame.origin.y <= _scrollViewStartPositionY) {
[self updateViewControlsWithSlideUp:YES];
}
if (sender.view.frame.origin.y > _scrollViewLimitMaxY) {
[self updateViewControlsWithSlideUp:NO];
}
return;
}
// 滑动速度处理
CGPoint velocity = [sender velocityInView:self.view];
CGFloat speed = 350;
if (velocity.y < - speed) {
// 快速向上
[self tableViewMoveToTop];
return;
} else if (velocity.y > speed) {
// 快速向下
[self tableViewMoveToBottom];
return;
}

// 滑动临界值
CGFloat criticalValue = _scrollViewLimitMaxY/2.0;
if (sender.view.frame.origin.y <= criticalValue) {
[self tableViewMoveToTop];
} else {
[self tableViewMoveToBottom];
}
}
}

这里几个点需要注意:

1. _beganPoint、_curPoint两个参数是用来计算手势滑动距离然后调整scrollView的滑动距离。而_previousOffsetY是用来记录滑动之前tableView的内部视图的偏移距离,因为当tableView滑动到顶部指定位置后,tableView开始滚动,这时候tableView向下滑动是先移动了tableView内部的滚动距离,然后才是滑动距离,因此需要将这部分值先记录,然后去除掉,才是tableView向下真正需要滑动的距离。

CGFloat offsetY = _previousOffsetY - self.tableView.contentOffset.y;
NSInteger y_offset = point.y - _beganPoint.y - offsetY;

2.滑动过程中,顶部视图的移动和渐变处理,这里先依据滑动的距离算出tableView滑动距离与tableView最大滑动距离的比值,然后再算出顶部视图需要移动的距离和背景的透明度。

- (void)updateViewControlsWhenSliding {
if (self.tableView.frame.origin.y > _scrollViewStartPositionY && self.tableView.frame.origin.y < _scrollViewLimitMaxY) {

CGFloat offsetLimitDistance = _scrollViewLimitMaxY - _scrollViewStartPositionY;
CGFloat offsetDistance = self.tableView.frame.origin.y - _scrollViewStartPositionY;
if (offsetDistance > 0 && offsetDistance < offsetLimitDistance) {
CGFloat topViewHeight = [FJFTopContainerView viewHeight];
CGFloat topViewHeightOffset = offsetDistance * (topViewHeight / offsetLimitDistance);
CGFloat viewAlpha = offsetDistance / offsetLimitDistance;
_topContainerView.y = topViewHeightOffset - topViewHeight;
_topContainerView.alpha = viewAlpha;
}
}
}

3.滑动速度处理,依据velocityInView函数获取速度值,然后依据当前速度值大小和正负和设定的速度值比较来判断是否需要向上或向下移动。

// 滑动速度处理
CGPoint velocity = [sender velocityInView:self.view];
CGFloat speed = 350;
if (velocity.y < - speed) {
// 快速向上
[self tableViewMoveToTop];
return;
} else if (velocity.y > speed) {
// 快速向下
[self tableViewMoveToBottom];
return;
}

4.滑动临界值处理,判断最后滑动位置与底部指定位置一半,两个值的大小来判断滑动的方向。

// 滑动临界值
CGFloat criticalValue = _scrollViewLimitMaxY/2.0;
if (sender.view.frame.origin.y <= criticalValue) {
[self tableViewMoveToTop];
} else {
[self tableViewMoveToBottom];
}

三.总结

这里最主要就是介绍了分析的思路,来找出可靠的实现方法,具体逻辑,详见demo

转自:https://www.jianshu.com/p/14dd820393fa

收起阅读 »

Android超级高效换肤框架,让你体验无闪烁换肤

用法1. 在Application中进行初始化public class SkinApplication extends Application { public void onCreate() { super.onCreate(); // Must ...
继续阅读 »

用法

1. 在Application中进行初始化

public class SkinApplication extends Application {
public void onCreate() {
super.onCreate();
// Must call init first
SkinManager.getInstance().init(this);
SkinManager.getInstance().load();
}
}

2. 在布局文件中标识需要换肤的View

...
xmlns:skin="http://schemas.android.com/android/skin"
...
<TextView
...
skin:enable="true"
... />

3. 继承BaseActivity或者BaseFragmentActivity作为BaseActivity进行开发

4. 从.skin文件中设置皮肤

String SKIN_NAME = "BlackFantacy.skin";
String SKIN_DIR = Environment.getExternalStorageDirectory() + File.separator + SKIN_NAME;
File skin = new File(SKIN_DIR);
SkinManager.getInstance().load(skin.getAbsolutePath(),
new ILoaderListener() {
@Override
public void onStart() {
}

@Override
public void onSuccess() {
}

@Override
public void onFailed() {
}
});

5. 重设默认皮肤

SkinManager.getInstance().restoreDefaultTheme();

6. 对代码中创建的View的换肤支持

主要由IDynamicNewView接口实现该功能,在BaseActivityBaseFragmentActivityBaseFragment中已经实现该接口.

public interface IDynamicNewView {
void dynamicAddView(View view, List<DynamicAttr> pDAttrs);
}

**用法:**动态创建View后,调用dynamicAddView方法注册该View至皮肤映射表即可(如下).详见sample工程

	private void dynamicAddTitleView() {
TextView textView = new TextView(getActivity());
textView.setText("Small Article (动态new的View)");
RelativeLayout.LayoutParams param = new RelativeLayout.LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
param.addRule(RelativeLayout.CENTER_IN_PARENT);
textView.setLayoutParams(param);
textView.setTextColor(getActivity().getResources().getColor(R.color.color_title_bar_text));
textView.setTextSize(20);
titleBarLayout.addView(textView);

List<DynamicAttr> mDynamicAttr = new ArrayList<DynamicAttr>();
mDynamicAttr.add(new DynamicAttr(AttrFactory.TEXT_COLOR, R.color.color_title_bar_text));
dynamicAddView(textView, mDynamicAttr);
}

7. 皮肤包是什么?如何生成?

  • 皮肤包(后缀名为.skin)的本质是一个apk文件,该apk文件不包含代码,只包含资源文件
  • 在皮肤包工程中(示例工程为skin/BlackFantacy)添加需要换肤的同名的资源文件,直接编译生成apk文件,再更改后缀名为.skinj即可(防止用户点击安装)
  • 使用gradle的同学,buildandroid-skin-loader-skin工程后即可在skin-package目录下取皮肤包(修改脚本中def skinName = "BlackFantacy.skin"换成自己想要的皮肤名)

代码下载:Android-Skin-Loader-master.zip

收起阅读 »

探究产生离屏渲染的秘密

一.渲染机制CPU将计算好的需要显示的内容提交给GPU,GPU渲染完成后将渲染结果放入帧缓冲区,随后视频控制器会按照Vsync(垂直脉冲)信号逐行读取帧缓冲区的数据,经过可能的数模转换传递给显示器进行显示。二.GPU屏幕渲染两种方式1.On-Screen Re...
继续阅读 »

一.渲染机制

CPU将计算好的需要显示的内容提交给GPU,GPU渲染完成后将渲染结果放入帧缓冲区,随后视频控制器会按照Vsync(垂直脉冲)信号逐行读取帧缓冲区的数据,经过可能的数模转换传递给显示器进行显示。

二.GPU屏幕渲染两种方式

1.On-Screen Rendering:当前屏幕渲染

指GPU的渲染操作是在当前用于显示的屏幕缓冲区中进行。

2.Off-Screen Rendering:离屏渲染

指GPU在当前屏幕缓冲区以外新开辟一个缓冲区进行渲染操作。

三.两种渲染方式比较

相比于当前屏幕渲染,离屏渲染的代价很高,主要体现在以下两个方面:

1.创建新缓冲区

要想进行离屏渲染,首先需要创建一个新的缓冲区。

2.上下文切换

离屏渲染的整个过程,需要多次进行上下文切换:先从当前屏幕(On-Screen)到离屏(Off-Screen);等到离屏渲染结束以后,将离屏缓冲区的渲染结果显示到屏幕上,又需要将上下文环境从离屏切换到当前屏幕。而上下文环境的切换回导致GPU产生空闲,而GPU拥有大量的并行计算的处理单元,这些处理单元都空闲,会产生巨大的浪费。

四.特殊的离屏渲染:CPU渲染

如果重写了drawRect方法,并且使用任何Core Graphics 的技术进行了绘制操作,就涉及到CPU渲染。整个渲染过程由CPU在App内同步完成,渲染得到的bitmap(位图)最后再交由GPU用于显示。

CoreGraphic通常是线程安全的,所以可以进行一步绘制,显示的时候再回主线程,一个简单异步绘制内容如下:

- (void)display {
dispatch_async(backgroundQueue, ^{
CGContextRef ctx = CGBitmapContextCreate(...);
// draw in context...
CGImageRef img = CGBitmapContextCreateImage(ctx);
CFRelease(ctx);
dispatch_async(mainQueue, ^{
layer.contents = img;
});
});
}

五.为什么产生离屏渲染

离屏渲染产生的原因主要有两方面:

1.在VSync(垂直脉冲)信号作用下,视频控制器每隔16.67ms就会去帧缓冲区(当前屏幕缓冲区)读取渲染后的数据;但是有些效果被认为不能直接呈现于屏幕前,而需要在别的地方做额外的处理,进行预合成。

比如图层属性的混合体再没有预合成之前不能直接在屏幕中绘制,所以就需要屏幕外渲染。屏幕外渲染并不意味着软件绘制,但是它意味着图层必须在被显示之前必须在一个屏幕外上下文中被渲染(不论CPU还是GPU)。

举个🌰:

UIView *AView = [[UIView alloc] initWithFrame:CGRectMake(100, 100, 200, 200)];
AView.backgroundColor = [UIColor redColor];
AView.alpha = 0.5;
[self.view addSubview:AView];

UIView *BView = [[UIView alloc] initWithFrame:CGRectMake(50, 50, 100, 100)];
BView.backgroundColor = [UIColor blackColor];
BView.alpha = 0.5;
[AView addSubview:BView];

效果图:


如上代码所示:

AView 视图包含BView视图,AView视图是红色,透明度为0.5;BView视图为黑色,透明度也为0.5,那么在渲染阶段,就会对AView和BView图层重叠的部分进行混合操作,但是这个过程并不适合直接显示在屏幕上,因此需要开辟屏幕外的缓存,对这两个图层进行屏幕外的渲染,然后将渲染的结果写回到当前屏幕缓存区。

这里有些人会有疑问,那如果能保证图层在16.67ms里完成渲染,视频控制器去读取的时候能读取到渲染完成的数据,不就可以了。

理论上,确实可以这样理解,但是图层之间的混合、渲染这个过程所耗费的时间是不固定的,跟多个维度相关,比如图层数量、重叠区域、GPU处理器性能等,因此底层设计的时候,应该是将不能够直接呈现在屏幕上的效果,都通过离屏渲染来操作。

2.有些视图渲染后的纹理需要被多次复用,但屏幕内的渲染缓冲区是实时更新的,所以需要通过开辟屏幕外的渲染缓冲区,将视图的内容渲染成纹理并缓存,然后再需要的时候在调入屏幕缓冲区,可以避免多次渲染的开销。

典型的例子就是光栅化。光栅化就是通过把视图的内容渲染成纹理并缓存,等到下次调用的时候直接去缓存的取出纹理,但是更新内容时候,会启用离屏渲染,所以更新的代价比较大,只能用于静态内容;而且如果光栅化的元素100ms没有被使用,也将被移除,故而不常用元素的光栅化并不会优化显示。

注意:光栅化的元素,总大小限制为2.5倍的屏幕。

六.如何检测离屏渲染

1.模拟器

模拟器在工作栏上面的Debug -> Color Off-Screen Rendered


2.真机

真机在工作栏上面的Debug -> View Debugging -> Rendering -> Color Off-Screen Rendered Yellow


七.引起离屏渲染操作和怎样优化

关于这方面的资料,可以参考文章:

离屏渲染优化详解:实例示范+性能测试

iOS-离屏渲染详解

如果想更深入的了解,可以了解下OpenGL、Metal、计算机图形学这方面的知识。

八.延伸阅读

离屏渲染优化详解:实例示范+性能测试

iOS-离屏渲染详解

Metal【1】—— 概述

iOS开发-视图渲染与性能优化

链接:https://www.jianshu.com/p/aa8dc1a61c91

收起阅读 »

Fragment问世这么久,你真的会用吗?

Fragment的简单用法 在一个Activity中添加两个Fragmet,并让这两个Fragment平分屏幕空间 首先新建一个左侧Fragmet布局left_fragment_xml,这里只放置一个按钮 <?xml version="1.0" enco...
继续阅读 »

Fragment的简单用法


在一个Activity中添加两个Fragmet,并让这两个Fragment平分屏幕空间


首先新建一个左侧Fragmet布局left_fragment_xml,这里只放置一个按钮


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent">
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:text="button"/>

</LinearLayout>
复制代码

新建一个右侧Fragment布局叫right_fragment_xml,一个文本框


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical"
android:background="#00ff00">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:textSize="24sp"
android:text="This is aright Fragment"/>
</LinearLayout>
复制代码

然后分别新建LeftFragmet和RightFragment两个类继承Fragment,并且重写onCreateView()方法


package com.example.fragmenttest

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment

class LeftFragment:Fragment() {
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return inflater.inflate(R.layout.left_fragment,container,false)
}
}
复制代码

package com.example.fragmenttest

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment

class LeftFragment:Fragment() {
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return inflater.inflate(R.layout.right_fragment,container,false)
}
}
复制代码

最后在man.xml标签中引入Fragment布局


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="match_parent">
<fragment
android:id="@+id/leftFrag"
android:name="com.example.fragmenttest.LeftFragment"
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="1"/>


<fragment
android:id="@+id/rightFrag"
android:name="com.example.fragmenttest.RightFragment"
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="1"/>




</LinearLayout>
复制代码

最后运行


截屏2021-05-09 下午8.51.49.png


动态添加Fragment


意思就是在运行程序时候动态添加Fragment


首先我们新建一个要添加得Fragment叫anther_rigt_fragment.xml


这里只是把颜色改为黄色背景


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:background="#ffff00">

<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal"
android:textSize="24sp"
android:text="This is anther right fragment"/>
</LinearLayout>
复制代码

下一步也是一样新建一个AotherRightFragment类继承Fragment,重写onCreateView()方法


kage com.example.fragmenttest

import android.os.Bundle
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment

class AntherRightFrogment :Fragment() {
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
return inflater.inflate(R.layout.anther_right_fragement,container,false)
}
}
复制代码

然后修改man.xml代码,引入FrameLayout布局,把右边的Fragment布局替换


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="match_parent">
<fragment
android:id="@+id/leftFrag"
android:name="com.example.fragmenttest.LeftFragment"
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="1"/>

<FrameLayout
android:id="@+id/rightFragment"
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="1"
/>

</LinearLayout>
复制代码

最后我们修改ManActivity的代码,为button设置监听器,达到点击BUTTON按钮,更换Fragment


class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
val button:Button=findViewById(R.id.button)
button.setOnClickListener{
repalce(AntherRightFrogment())
}
repalce(RightFragment())
}
private fun repalce(fragment:Fragment){
//就是获取所在fragment的父容器的管理器,
val fragementManager=supportFragmentManager
//开启一个事务
val transaction=fragementManager.beginTransaction()
//添加和替换Fragment
transaction.replace(R.id.rightFragment,fragment)
//返回栈
transaction.addToBackStack(null)
//提交事务
transaction.commit()

}
复制代码

在Fragment中实现返回栈


按下back建返回上一个Fragment


        //返回栈
transaction.addToBackStack(null)
复制代码

Fragment生命周期


onAttach():Fragment和Activity相关联时调用


onCreate():系统创建Fragment时调用


onCreateView():创建Fragment的布局(视图)调用


onActivityCreated():确保与Fragment相关联的Activity调用完时调用


首先我们修改RightFragment代码来看效果


package com.example.fragmenttest

import android.content.Context
import android.os.Bundle
import android.util.Log
import android.view.LayoutInflater
import android.view.View
import android.view.ViewGroup
import androidx.fragment.app.Fragment

class RightFragment :Fragment(){
companion object{
const val TAG="RightFragment"
}
//当Fragment和Activity建立关联时调用
override fun onAttach(context: Context) {
super.onAttach(context)
Log.d(TAG,"onAttach")
}

override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
Log.d(TAG,"onCteate")
}
//为Fragment创建视图获加载布局时调用
override fun onCreateView(
inflater: LayoutInflater,
container: ViewGroup?,
savedInstanceState: Bundle?
): View? {
Log.d(TAG,"onCreateView")
return inflater.inflate(R.layout.right_fragment,container,false)
}
//确保和Fragment相关联的Activity已经创建完毕时候调用
override fun onActivityCreated(savedInstanceState: Bundle?) {
super.onActivityCreated(savedInstanceState)

Log.d(TAG,"onActivityCreated")
}

override fun onStart() {
super.onStart()
Log.d(TAG,"onStart")
}

override fun onResume() {
super.onResume()
Log.d(TAG,"onResume")
}

override fun onPause() {
super.onPause()
Log.d(TAG,"onPause")
}

override fun onStop() {
super.onStop()
Log.d(TAG,"onStop")
}
//当与Fragment先关联的视图移除时候调用
override fun onDestroyView() {
super.onDestroyView()
Log.d(TAG,"onDestroyView")
}

override fun onDestroy() {
super.onDestroy()
Log.d(TAG,"onDestroy")
}
//当Fragment与Activity解除关联时候调用
override fun onDetach() {
super.onDetach()
Log.d(TAG,"onDetach")
}

}
复制代码

首次加载RightFragment


截屏2021-05-09 下午8.56.39.png


按下Button按钮


截屏2021-05-09 下午8.57.02.png


按下Back键返回


截屏2021-05-09 下午8.57.18.png


再次按下Back键


截屏2021-05-09 下午8.57.34.png


使用限定符


这个作用比较大例如一般平板使用双页符,因为屏幕比较大任性,但是我们手机就不同了屏幕空间小,


只能显示一页,那么怎么才能让运行程序的程序自动判断到底用那页了,这时候就使用我们的限定符(qualifier)实现。


首先我们修改activity.main.xml代码,只留下我们左边的Fragment,就是带一个button按钮的,把它就用做我们手机的单页显示。


修改 android:layout_width="match_parent让它宽度和父布局一样占满空间


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="match_parent">
<fragment
android:id="@+id/leftFrag"
android:name="com.example.fragmenttest.LeftFragment"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:layout_weight="1"/>



</LinearLayout>
复制代码

接着在res目录下新建一个layout-large文件夹,然后在这个文件夹下添加一个新的activity_main.xml布局,代码就是前面双页布局,这里只修改屏幕占比,这里large就是一个限定符,认为是large的设备就加载这个个layout-large文件夹布局。


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="horizontal"
android:layout_width="match_parent"
android:layout_height="match_parent">

<fragment
android:id="@+id/leftFrag"
android:name="com.example.fragmenttest.LeftFragment"
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="1"/>
<fragment
android:id="@+id/rightFrage"
android:name="com.example.fragmenttest.RightFragment"
android:layout_width="0dp"
android:layout_height="match_parent"
android:layout_weight="3"/>

</LinearLayout>
复制代码

最后运行代码在平板上


截屏2021-05-09 下午8.58.11.png


在手机上


截屏2021-05-09 下午8.58.29.png


最小宽度限定符


large解决了单双页的问题,那么这个large到底多大了,这里我们映入了最小宽度限定符,它允许我们为屏幕指定一个最小值以dp为单位,超过这个最小值,则加载一个布局,那么小于则执行另外一个。


首先我们在res目录下兴建一个layout_sw600dp文件夹,再次兴建activity_main.xml布局


这里的600dp就是一个临界点,代码都一样就是把两个布局加载


运行的结果,当然看你运行的屏幕了,但宽度大于600dp就加载layout_sw600目录下的activity_main.xml布局,小与600dp就加载默认的,就是layout目录下activity_main.xml布局


作者:用户2069379142245
链接:https://juejin.cn/post/6960273662704353294
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

iOS — Swift高级分享:SWIFT协议的替代方案

毫无疑问,协议是SWIFT总体设计的主要部分-并且可以提供一种很好的方法来创建抽象、分离关注点和提高系统或功能的整体灵活性。通过不强烈地将类型绑定在一起,而是通过更抽象的接口连接代码库的各个部分,我们通常会得到一个更加解耦的体系结构,它允许我们孤立地迭代每个单...
继续阅读 »

毫无疑问,协议是SWIFT总体设计的主要部分-并且可以提供一种很好的方法来创建抽象、分离关注点和提高系统或功能的整体灵活性。通过不强烈地将类型绑定在一起,而是通过更抽象的接口连接代码库的各个部分,我们通常会得到一个更加解耦的体系结构,它允许我们孤立地迭代每个单独的特性。

然而,虽然协议在许多不同的情况下都是一个很好的工具,但它们也有各自的缺点和权衡。本周,让我们来看看其中的一些特性,并探索几种在SWIFT中抽象代码的替代方法-看看它们与使用协议相比如何。

使用闭包的单个需求

使用协议抽象代码的优点之一是它允许我们对多个代码进行分组。所需在一起。例如,PersistedValue协议可能需要两个save和一个load方法-这两种方法都使我们能够在所有这些值之间强制执行一定程度的一致性,并编写用于保存和加载数据的共享实用程序。

然而,并不是所有的抽象都涉及多个需求,并且非常常见的协议只有一个方法或属性-比如这个:

protocol ModelProvider {
associatedtype Model: ModelProtocol
func provideModel() -> Model
}

假设上面的ModelProvider协议用于抽象我们在代码库中加载和提供模型的方式。它使用关联类型,以便让每个实现以非常类型安全的方式声明它提供的模型类型,这是很棒的,因为它使我们能够编写通用代码来执行常见任务,例如为给定模型呈现详细视图:

class DetailViewController<Model: ModelProtocol>: UIViewController {
private let modelProvider: AnyModelProvider<Model>

init<T: ModelProvider>(modelProvider: T) where T.Model == Model {
// We wrap the injected provider in an AnyModelProvider
// instance to be able to store a reference to it.
self.modelProvider = AnyModelProvider(modelProvider)
super.init(nibName: nil, bundle: nil)
}

override func viewDidLoad() {
super.viewDidLoad()

let model = modelProvider.provideModel()
...
}

...
}

虽然上面的代码可以工作,但它说明了使用具有关联类型的协议的缺点之一-我们不能将引用存储到ModelProvider直接。相反,我们必须首先执行类型擦除将我们的协议引用转换成一个具体的类型,这两种类型都会使我们的代码混乱,并要求我们实现其他类型,以便能够使用我们的协议。

因为我们所处理的协议只有一个要求,所以问题是-我们真的需要吗?毕竟,我们ModelProvider协议没有添加任何额外的分组或结构,因此让我们取消它的唯一要求,将其转化为闭包-然后可以直接注入,如下所示:

class DetailViewController<Model: ModelProtocol>: UIViewController {
private let modelProvider: () -> Model

init(modelProvider: @escaping () -> Model) {
self.modelProvider = modelProvider
super.init(nibName: nil, bundle: nil)
}

override func viewDidLoad() {
super.viewDidLoad()

let model = modelProvider()
...
}

...
}

通过直接注入我们需要的功能,而不是要求类型符合协议,我们还大大提高了代码的灵活性-因为我们现在可以自由地注入任何东西,从空闲函数到内联定义的闭包,再到实例方法。我们也不再需要执行任何类型删除,留给我们的代码要简单得多。

使用泛型类型

虽然闭包和函数是建模单个需求抽象的好方法,但是如果我们开始添加额外的需求,那么使用它们可能会变得有点混乱。例如,假设我们希望扩展上面的内容DetailViewController也支持书签和删除模型。如果我们坚持基于闭包的方法,我们最终会得到这样的结果:

class DetailViewController<Model: ModelProtocol>: UIViewController {
private let modelProvider: () -> Model
private let modelBookmarker: (Model) -> Void
private let modelDeleter: (Model) -> Void

init(modelProvider: @escaping () -> Model,
modelBookmarker: @escaping (Model) -> Void,
modelDeleter: @escaping (Model) -> Void) {
self.modelProvider = modelProvider
self.modelBookmarker = modelBookmarker
self.modelDeleter = modelDeleter

super.init(nibName: nil, bundle: nil)
}

...
}

上述设置不仅要求我们跟踪多个独立闭包,而且还会出现大量重复的闭包。“模型”前缀-(使用“三人规则”)告诉我们,我们这里有一些结构性问题。而我们能回到将上述所有闭包封装到一个协议中去,这再次要求我们执行类型擦除,并失去我们在开始使用闭包时获得的一些灵活性。

相反,让我们使用泛型类型将我们的需求组合在一起-这两种类型都允许我们保留使用闭包的灵活性,同时在代码中添加一些额外的结构:

struct ModelHandling<Model: ModelProtocol> {
var provide: () -> Model
var bookmark: (Model) -> Void
var delete: (Model) -> Void
}

因为上面是一个具体的类型,所以它不需要任何形式的类型擦除(实际上,它看起来非常类似于我们在使用带关联类型的协议时经常被迫编写的类型擦除包装)。因此,就像闭包一样,它可以直接使用和存储-如下所示:

class DetailViewController<Model: ModelProtocol>: UIViewController {
private let modelHandler: ModelHandling<Model>
private lazy var model = modelHandler.provide()

init(modelHandler: ModelHandling<Model>) {
self.modelHandler = modelHandler
super.init(nibName: nil, bundle: nil)
}

@objc private func bookmarkButtonTapped() {
modelHandler.bookmark(model)
}

@objc private func deleteButtonTapped() {
modelHandler.delete(model)
dismiss(animated: true)
}

...
}

而具有关联类型的协议在定义更高级别的需求时非常有用(就像标准库的Equatable和Collection),当这样的协议需要直接使用时,使用独立闭包或泛型类型通常可以给我们相同的封装级别,但通过一个简单得多的抽象。

使用枚举分离要求

在设计任何类型的抽象时,一个常见的挑战是不要。“过于抽象”通过添加太多的需求。例如,现在假设我们正在开发一个应用程序,它允许用户使用多种媒体-比如文章、播客、视频等等-我们希望为所有这些不同的格式创建一个共享的抽象。如果我们再次从面向协议的方法开始,我们可能会得到这样的结果:

protocol Media {
var id: UUID { get }
var title: String { get }
var description: String { get }
var text: String? { get }
var url: URL? { get }
var duration: TimeInterval? { get }
var resolution: Resolution? { get }
}

由于上面的协议需要与所有不同类型的媒体一起工作,我们最终得到了多个仅与某些格式相关的属性。例如,Article类型没有任何概念持续时间或分辨力-留给我们一些我们必须实现的属性,因为我们的协议要求我们:

struct Article: Media {
let id: UUID
var title: String
var description: String
var text: String?
var url: URL? { return nil }
var duration: TimeInterval? { return nil }
var resolution: Resolution? { return nil }
}

上面的设置不仅要求我们在符合标准的类型中添加不必要的样板,还可能是歧义的来源-因为我们无法强制规定一篇文章实际上包含文本,或者应该支持URL、持续时间或解析的类型实际上携带了该数据-因为所有这些属性都是选项。

我们可以通过多种方法解决上述问题,从将协议拆分为多个协议开始,每个方法都具有提高专业化程度-像这样:

protocol Media {
var id: UUID { get }
var title: String { get }
var description: String { get }
}

protocol ReadableMedia: Media {
var text: String { get }
}

protocol PlayableMedia: Media {
var url: URL { get }
var duration: TimeInterval { get }
var resolution: Resolution? { get }
}

以上所述无疑是一种改进,因为它将使我们能够拥有以下类型Article符合ReadableMedia,和可玩类型(如Audio和Video)符合PlayableMedia-减少歧义和样板,因为每种类型都可以选择哪一种专门版本的Media它想要遵守的。

但是,由于上述协议都是关于数据的,因此使用实际数据类型相反,这既可以减少重复实现的需要,也可以让我们通过单一的具体类型来处理任何媒体格式:

struct Media {
let id: UUID
var title: String
var description: String
var content: Content
}

上面的结构现在只包含我们所有媒体格式之间共享的数据,除了content属性-这就是我们将用于专门化的内容。但这一次,而不是Content一个协议,让我们使用枚举-它将使我们能够通过关联的值为每种格式定义一组量身定做的属性:

extension Media {
enum Content {
case article(text: String)
case audio(Playable)
case video(Playable, resolution: Resolution)
}

struct Playable {
var url: URL
var duration: TimeInterval
}
}

选项已经消失,我们现在已经在共享抽象和启用特定于格式的专门化之间取得了很好的平衡。枚举的美妙之处还在于,它使我们能够表达数据变化,而不必使用泛型或协议-只要我们预先知道变体的数量,一切都可以封装在相同的具体类型中。

类和继承

另一种方法在SWIFT中可能不像在其他语言中那么流行,但仍然值得考虑,那就是使用通过继承专门化的类来创建抽象。例如,而不是使用Content为了实现上述媒体格式,我们可以使用Media基类,然后将其子类化,以添加特定于格式的属性,如下所示:

class Media {
let id: UUID
var title: String
var description: String

init(id: UUID, title: String, description: String) {
self.id = id
self.title = title
self.description = description
}
}

class PlayableMedia: Media {
var url: URL
var duration: TimeInterval

init(id: UUID,
title: String,
description: String,
url: URL,
duration: TimeInterval) {
self.url = url
self.duration = duration
super.init(id: id, title: title, description: description)
}
}

然而,尽管从结构的角度来看,上述方法是完全有意义的-但它也有一些不利之处。首先,由于类还不支持按成员划分的初始化器,所以我们必须自己定义所有初始化器-我们还必须通过调用super.init..但也许更重要的是,课程是参考类型,这意味着在共享时,我们必须小心避免执行任何意外的突变。Media跨代码库的实例。

但这并不意味着SWIFT中没有有效的继承用例。例如,在“在未来的引擎盖下&斯威夫特的承诺”,继承提供了一种公开只读的好方法。Future类型到api用户-同时仍然允许通过Promise子类:

class Future<Value> {
fileprivate var result: Result<Value, Error>? {
didSet { result.map(report) }
}

...
}

class Promise<Value>: Future<Value> {
func resolve(with value: Value) {
result = .success(value)
}

func reject(with error: Error) {
result = .failure(error)
}
}

func loadCachedData() -> Future<Data> {
let promise = Promise<Data>()
cache.load { promise.resolve(with: $0) }
return promise
}

使用上面的设置,我们可以让同一个实例在不同的上下文中公开不同的API集,当我们只允许其中一个上下文对给定的对象进行变异时,这是非常有用的。在使用泛型代码时尤其如此,因为如果我们尝试使用一个协议来实现相同的目标,我们将再次遇到关联类型问题。

结语

在可预见的将来,协议是很棒的,并且很可能仍然是在SWIFT中定义抽象的最常用的方式。然而,这并不意味着使用协议永远是最好的解决方案-有时会超越流行的范围“面向协议的编程”MARRA可以产生更简单、更健壮的代码-特别是当我们想要定义的协议要求我们使用关联类型的时候。

链接:https://www.jianshu.com/p/74d511140089

收起阅读 »

iOS OC开发 BTC、ETH、区块链钱包

ETH钱包部分:功能有:1、创建钱包2、通过助记词导入钱包3、通过KeyStore导入钱包4、通过私钥导入钱包5、查询余额6、查询以太坊系代币余额7、转账BTC钱包部分:功能:1、创建钱包2、通过私钥导入钱包3、通过助记词导入钱包4、查询余额5、查询交易记录6...
继续阅读 »

ETH钱包部分:

功能有:

1、创建钱包

2、通过助记词导入钱包

3、通过KeyStore导入钱包

4、通过私钥导入钱包

5、查询余额

6、查询以太坊系代币余额

7、转账



BTC钱包部分:

功能:

1、创建钱包

2、通过私钥导入钱包

3、通过助记词导入钱包

4、查询余额

5、查询交易记录

6、发起交易



项目连接:


ETH钱包Demo:https://github.com/Ccct/CCTEthereum/

BTC钱包Demo:https://github.com/Ccct/CCTBTC

链接:https://www.jianshu.com/p/1b8c1ed88e69
收起阅读 »

ARC对init方法的处理

前言此文源于前几日工作中遇到的一个问题,并跟同事就init方法进行了相关讨论。相关代码如下:Person *myPerson = [Person alloc];NSMethodSignature *signature = [NSMethodSignature ...
继续阅读 »

前言

此文源于前几日工作中遇到的一个问题,并跟同事就init方法进行了相关讨论。相关代码如下:

Person *myPerson = [Person alloc];
NSMethodSignature *signature = [NSMethodSignature signatureWithObjCTypes:"@16@0:8"];
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
invocation.target = myPerson;
invocation.selector = @selector(initPerson);
[invocation invoke];
__unsafe_unretained id retValue;
[invocation getReturnValue:&retValue];

正常来说,这段代码运行起来没有任何问题。然而,当Person的initPerson方法返回nil或者返回子类对象时,上述代码就会EXC_BAD_ACCESS。但如果我们把initPerson方法前缀改成其他(比如:createPerson),就不会crash。为了查清原因,便对init方法进行了一次探索(说探索多少有些夸张)。

通过符号断点及反汇编等调试手段,发现在initPerson方法结束的时候,person对象调用了一次release,而上述示例代码执行完,ARC为了抵消[Person alloc]这步操作,会对myPerson进行一次release。也就是说,过渡释放引起了crash。

那么接下来,我们就看下init方法结束的时候,为什么要调用那次看似多余的release?

原因分析

在clang文档中找到这么两个东西:__attribute__((ns_consumes_self))、__attribute((ns_returns_retained))。

据文档描述,前者的作用是将ownership从主调方转移到被调方;而后者的作用是把ownership从被调方转移到主调方。具体原理如下:

0x1. __attribute__((ns_consumes_self))

若某个方法被标记这个特性,调用方会在方法调用前对receiver进行一次retain(也可能会被编译器优化掉),而被调方会在方法结束的时候对self进行一次release。比如下面代码

// 主调方
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
Person *myPerson = [[Person alloc] init];
[myPerson noninitPerson]; // 以非init方法来测试
return YES;
}

// 被调方
@interface Person : NSObject
- (void)noninitPerson __attribute__((ns_consumes_self));
@end

@implementation Person
- (void)noninitPerson {
}
@end

通过Hopper反汇编,伪代码如下:

// 主调方
bool -[AppDelegate application:didFinishLaunchingWithOptions:](void * self, void * _cmd, void * arg2, void * arg3) {
var_28 = [[Person alloc] init];
rax = [var_28 retain]; // 调用前retain
[rax noninitPerson]; // 开始调用
objc_storeStrong(var_28, 0x0);
return rax;
}

// 被调方
void -[Person noninitPerson](void * self, void * _cmd {
objc_storeStrong(self, 0x0); // 调用完被调方负责release
return;
}

而init开头的方法会被隐式地标记这个特性,文档中有描述:

The implicit self parameter of a method may be marked as consumed by adding __ attribute __((ns_consumes_self)) to the method declaration. Methods in theinitfamily are treated as if they were implicitly marked with this attribute.

0x2. __attribute__((ns_returns_retained))

若方法标记这个特性,表示主调方希望得到一个retainCount+1的对象,即被调方可能会进行一次retain将所有权移交给主调方,主调方会进行一次release(可能会被编译器优化掉)来负责释放。

伪代码如下:

// 主调方
var_28 = [[Person alloc] init];
rax = [var_28 running];
[rax release]; // 主调方负责释放

// 被调方
void * -[Person running](void * self, void * _cmd) {
rax = [self retain]; // 若这里返回一个新分配的对象,则无需retain
return rax;
}

同样地,init开头的方法也会被标记这个特性,文档里亦有体现:

Methods in the alloc, copy, init, mutableCopy, and new families are implicitly marked __ attribute __((ns_returns_retained)).

这么多的retain、release,多少有些凌乱,既然已知init方法会被标记__attribute__((ns_returns_retained))和__attribute__((ns_consumes_self)),那我们干脆看下init方法反汇编后的代码:

// 主调方
bool -[AppDelegate application:didFinishLaunchingWithOptions:](void * self, void * _cmd, void * arg2, void * arg3) {
var_28 = [[Person alloc] init];
objc_storeStrong(var_28, 0x0);
// 优化掉了一对retain/release
return rax;
}

// 被调方
void * -[Person init](void * self, void * _cmd) {
// 忽略一些无关指令
var_18 = [self retain]; // 对应__attribute__((ns_returns_retained))
objc_storeStrong(self, 0x0); // 对应__attribute__((ns_consumes_self))
rax = var_18;
return rax;
}

到这里,我们基本了解了init方法原理,那么离文章开头那段代码crash又如何解释呢?我们对代码稍作修改,让init方法返回nil,再看下:

// 主调方
bool -[AppDelegate application:didFinishLaunchingWithOptions:](void * self, void * _cmd, void * arg2, void * arg3) {
var_28 = [[Person alloc] init];
objc_storeStrong(var_28, 0x0);
return rax;
}

// 被调方
void * -[Person init](void * self, void * _cmd) {
// 因为返回nil,所以这里的retain不存在了,而下面的self依然要消费掉
objc_storeStrong(self, 0x0); // 对应__attribute__((ns_consumes_self))
return 0x0;
}

至此,过度释放的原因也就清楚了,那么该怎么解决呢?

解决方案

回到文章开头,再看下代码,不难发现,我们只要模仿ARC在init方法调用前插入个retain,并在主调方快结束的时候再插入个release即可。

Person *myPerson = [Person alloc];
NSMethodSignature *signature = [NSMethodSignature signatureWithObjCTypes:"@16@0:8"];
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:signature];
invocation.target = myPerson;
invocation.selector = @selector(initPerson);
CFBridgingRetain(myPerson); // 代替ARC将owneship将传递给被调方
[invocation invoke];

__unsafe_unretained id retValue;
[invocation getReturnValue:&retValue];

CFBridgingRelease((__bridge CFTypeRef)retValue); // 代替ARC来释放ns_returns_retained结果

如果init方法返回nil,即retValue=nil,则CFBridgingRelease不会生效,上面插的那个CFBridgingRetain也就完美抵消掉了init方法结束时的release。

链接:https://www.jianshu.com/p/51adf5b44588

收起阅读 »

视频超过三十秒后再接受 无数据

视频超过三十秒后再接受 无数据

视频超过三十秒后再接受 无数据


Charles使用教程汇总

Charles教程汇总 1.  简介    ●    Charles,一款代理抓包工具,可以分析和排查网络相关的问题●    支持移动(安卓、iOS)...
继续阅读 »

Charles教程汇总

 

1.  简介

    

    Charles,一款代理抓包工具,可以分析和排查网络相关的问题

    支持移动(安卓、iOS)设备

    以下使用文档,以安卓设备为准,iOS设置大同小异

 

2.  Charles安装

    安装包官方下载:http://www.charlesproxy.com/documentation/

    官方版为试用版,启动时有10s等待时间,每隔30min会提示关闭,重新打开后可以继续使用30min

3.  Charles代理配置使用

1)   打开Charles 

2)   查看本地IP

        

3)   手机连接WiFi(此WiFi需要和电脑在同一网段内,公司内直接连接cheetahmobile即可)

4)   设置手机代理

a)   长按cheetahmobile无线网络

b)   选择修改网络

  

c)   勾选高级选项,将代理设置为手动,填入步骤2获取的IP地址,代理服务器端口默认为8888


d)   手机中打开应用,产生网络请求,电脑端同意连接

e)   如在公司外使用,先将电脑未连接VPN之前的IP设置为手机的代理服务器地址,手机连接电脑之后


5)Access
Control

这个功能可以管理目前连接到你电脑上的设备(包括添加,删除,导入导出配置文件等,另外,Charles还提供了能够让所有设备无须询问直接连接电脑的方式:添加一个0.0.0.0/0的IP即可)

有时可能会遇到手机连接到电脑之后,无访问许可请求,此时可以去access
Control中手动进行添加

对Charles有大量使用需求的同学,时间久了之后,access
control里可能会有很多IP,建议大家在每次的测试开始前,清理IP池,将本次要测试的手机添加到自己的访问名单(使用Charles过程中,需要修改网络请求数据和host,如果不维护IP池,可能会干扰你自己或者别人的测试)

4.  修改默认的8888端口号

    测试过程中,默认代理填入的端口号为8888,设备之间经常借调,会导致其他人依旧连接你的代理

    可以手动修改默认的8888端口号

1)   打开设置面板

2)   修改默认的端口号保存即可

 

5.  设置本地(电脑端)不走Charles代理

    本地走代理部分情况下会导致上网慢(如有针对情况下限速),且电脑端产生的请求较多,容易刷屏

1)   Proxy--Proxy
Setting… 

2)  
定位到WindowsMozilla FireFox

3)   将下方的复选框取消勾选后保存

4)   以后再次启动Charles后,电脑端的所有请求就不会被Charles抓包 

 

6.  设置关注的域名

    抓包域名比较多情况下,容易刷屏,可以将需要测试的域名添加到关注列表,方便查看

1)   产生的网络请求中,选中后右键选择Focus

2)   再次产生改请求的情况下就会在前面,而未关注的域名就会被分配到Other
Hosts下


 

7.  域名重定向(A-->B)

    测试过程中客,可能会将户端A域名的请求访问到B域名上

1)   找到需要重定向(A)的域名,右键选择Map Remote...

        

2)   填入对应域名的信息后保存(A-->B)


3)   客户端再次请求,下发的域名变为B

        

       

8.  域名重定向(A-->本地文件)

    测试过程中,需要看客户端对服务端数据的容错,如果服务端没有给脏数据,则需要本地模拟脏数据

    需要对一个字段进行多次校验工作,服务端配置麻烦可以采用本地方式

1)   将正常访问的域名的response数据,复制保存到本地(格式无所谓,txt、json都可以)

2)   选择域名,右键访问的链接,选择Map Local

3)   在Local Path路径中,将本地保存的数据选中

4)   客户端再次请求时,访问的数据即为本地数据


 

9.  查看已配置的重定向设置

    查看和取消Map Local和Map Remote已经设置的重定向

1)   点击菜单中的Tools

2)   需要取消重定向设置,将已配置的数据删除或者选择Enable
Map
Local开关即可


10. 设置限速

    查看网络加载慢情况下,客户端的容错及反馈情况

1)   打开限速设置窗口

        

2)   限速可以针对选定的域名,也可以针对生效

3)   也可以参照Facebook开源的方案进行设置

a)   限速提供了通用的方案,比如Custom,3G等方案

b)   可以手动设置解决方案 


 

海外项目,建议参照Facebook的ATC解决方案来模拟

    Facebook
ATC提供了将近10种类型的网络参数设置,包含了发达国家,发展中国家,郊区、市区等网络情况


 

11. https解密抓包

    安全起见,公司部分域名采用了https的方式,https是加密,常规情况下无法抓到包请求


1)   开启Charles

2)   电脑端安装Charles证书

a)  
Help--SSL
Proxying--install Charles Root Certificate


b)   安装证书


c)   证书安装到“受新人的发布者”下


3)   手机端安装电脑证书

a)   手机访问域名:http://www.charlesproxy.com/getssl/

b)  
部分浏览器如果提示证书下载失败,就换个浏览器,目前QQ浏览器亲测有效

c)   安装证书,证书名字随便写

d)   安装证书需要设置锁屏密码

4)   安装成功后,Charles客户端开启对应的域名SSL


5)   设置对应域名的网络连接,https默认端口为443


6)   设置成功后,访问域名,即可查看解密后的请求状况


12. 重复请求

    对于一些客户端不容易触发的请求,可以通过charles中repeat功能进行重复请求,简单方便

1)   选中请求的URL,右键选择Repeat


2)   即可查看请求的结果

 

13. 对接口进行压力测试

 

1)   选中要进行压测的接口,右键选择Repeat Advanced…


2)   填入重复执行的次数和并发数

a)   Itreations:循环次数

b)   Concurrency:并发次数

c)   Delays,请求与请求之间的间隔时间

    并发代表是统一时间内请求多少次,比如设置循环6次,每次并发3条,则会分2次,每次并发3条去向服务端进行请求(需要注意的是,如果循环次数不是并发次数的整数倍,则不会触发所有的请求,如设置循环次数为10,并发条数为3,那么最终只会发起9次请求)

 


3)   查看测试结果


14. 修改请求参数之Edit

    验证不同请求参数下,接口是否返回对应的数据

    比如发魔方数据,限制了MCC为460以内的生效,那就可以改MCC为非460,看是否还能请求到对应的开关信息

1)   选中对应请求,选择Edit


2)   修改参数请求参数后点Execute


3)   重新请求后,请求参数中就包含了对应的参数


 

15. 修改请求参数之Rewrite 

    客户端的云端开关,大多是通过魔方下发,不同的MCC,语言和aid会下发不同的数据,客户端如果要拉取不同的配置时,需要修改这些参数。修改MCC和aid还需要在root的设备上使用三方工具,随着Android版本的升级,部分参数甚至无法修改

    广告和新闻的数据,会区分国际进行投放,有时甚至只会针对特定的国家(如印度新闻)投放,客户端为了测试这些功能,需要借助VPN或者debug版本

    与MCC和aid修改器说再见

1)   打开Rewrite设置


2)   添加一条配置信息

a)   打开Enable Rewite功能开关


b)   添加一条配置信息

c)   Location中,添加域名的详细信息


3)   对域名添加对应的规则

a)  修改URL中的请求参数,比如MCC,aid等,Type选择:Modify
Query Param

b)  修改URL中的地域,比如添加某个国家的IP,Type选择:Add
Header


   举个栗子:

   例子1:客户端需要请求只针对MCC为310且aid尾号为1的用户下发的魔方云端配置

1.   配置魔方域名


2.   Type选择:Modify Query Param,并填写对应的参数

        


3.   打开开关,客户端再次发生请求



 

   例子2:客户端需求请求只针对印度IP下发的picks广告数据

1.   配置对应域名的数据


2.   新增一个请求参数


3.   再次请求对应链接


 

   例子3:客户端需要请求只针对英国IP下发的新闻数据

1.   配置对应域名的数据


2.   选择Type为Add Header


3.   客户端再去触发请求,抓包查看X-Forwarded-For已修改为2.101.8.8


 

16. session的操作

                    Charles支持同时打开多个session,但新发起的网络请求,只会在最后建议的session中进行记录

                    Charles还支持将session进行保存,在需要的时候可以将session作为Charles的日志提供给其他需要的人进行查看

17. 两种数据查看方式:structur和sequence


18. 复制和保存请求内容

            
1.    
在某个请求上右键选择“copy
URL”,可以将本次请求的完整URL复制出来

            
2.    
在某个请求上右键选择“copy
response”,可以将本次返回数据的完整内容复制出来

            
3.    
在某个请求上右键选择“save
response”,可以将本次返回数据的完整内容以文件的形式保存在本地

19. 选择内容查看方式

            
1.    
在某个请求上右键选择“view
response as”并进一步选择需要的数据查看方式(有时候返回的内容,Charles不能直接提供json的查看方式,可以用这个功能来强行查看josn格式)

            
2.    
同理,可以在某个请求上右键选择“view
request as”并进一步选择需要的数据查看方式

 

     20.对添加ignore的域名取消忽略

            
1.    
忽略对应的域名


            
2.    
进入Proxy--Recording Settings,进入Exclude取消remove即可


收起阅读 »

iOS-TCP网络框架(二)

现在我们已经有了TCP连接, Request, Response和Task, 接下来要做的就是把这一切串起来. 具体来说, 我们需要一个管理方建立并管理TCP连接, 提供接口让调用方通过Request向连接中写入数据, 监听连接中读取到的粘包数据并将数据拆分成...
继续阅读 »

现在我们已经有了TCP连接, Request, Response和Task, 接下来要做的就是把这一切串起来. 具体来说, 我们需要一个管理方建立并管理TCP连接, 提供接口让调用方通过Request向连接中写入数据, 监听连接中读取到的粘包数据并将数据拆分成单个Response返回给调用方.

TCP连接部分比较简单, 这里我们直接跳过, 从发起数据请求部分开始.

发起数据请求

站在调用方的角度, 发起一个TCP请求与发起一个HTTP请求并没有什么区别. 调用方通过Request提供URL和相应参数, 然后通过completionHandler回调处理请求对应的响应数据, 就像这样:


// SomeViewController.m

- (void)fetchData {

HHTCPSocketRequest *request = [HHTCPSocketRequest requestWithURL:aTCPUrl parameters:someParams header:someHeader];
HHTCPSocketTask *task = [[HHTCPSocketClient sharedInstance] dataTaskWithRequest:request completionHandler:^(NSError *error, id result) {
if (error) {
//handle error
} else {
//handle result
}
}
[task resume];
}
站在协议实现方的角度, 发起网络请求做的事情会多一些. 我们需要将调用方提供的Request和completionHandler打包成一个Task并保存起来, 当调用方调用Task.resume时, 我们再将Request.data写入Socket. 这部分的主要代码如下:

//HHTCPSocketClient.m

@interface HHTCPSocketClient()<HHTCPSocketDelegate>

@property (nonatomic, strong) HHTCPSocket *socket;

//任务派发表 以序列号为键保存所有已发出但还未收到响应的Request 待收到响应后再根据序列号一一分发
@property (nonatomic, strong) NSMutableDictionary<NSNumber *, HHTCPSocketTask *> *dispatchTable;

...其他逻辑 略
@end

@implementation HHTCPSocketClient

...其他逻辑 略

#pragma mark - Interface(Public)

//新建数据请求任务 调用方通过此接口定义Request的收到响应后的处理逻辑
- (HHTCPSocketTask *)dataTaskWithRequest:(HHTCPSocketRequest *)request completionHandler:(HHNetworkTaskCompletionHander)completionHandler {

__block NSNumber *taskIdentifier;
//1\. 根据Request新建Task
HHTCPSocketTask *task = [HHTCPSocketTask taskWithRequest:request completionHandler:^(NSError *error, id result) {

//4\. Request已收到响应 从派发表中删除
dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
[self.dispatchTable removeObjectForKey:taskIdentifier];
dispatch_semaphore_signal(lock);

!completionHandler ?: completionHandler(error, result);
}];
//2\. 设置Task.client为HHTCPSocketClient 后续会通过Task.client向Socket中写入数据
task.client = self;
taskIdentifier = task.taskIdentifier;

//3\. 将Task保存到派发表中
dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
[self.dispatchTable setObject:task forKey:taskIdentifier];
dispatch_semaphore_signal(lock);

return task;
}

- (NSNumber *)dispatchTask:(HHTCPSocketTask *)task {
if (task == nil) { return @-1; }

[task resume];// 通过task.resume接口发起请求 task.resume会调用task.client.resumeTask方法 task.client就是HHTCPSocketClient
return task.taskIdentifier;
}

#pragma mark - Interface(Friend)

//最终向Socket中写入Request.data的地方 此接口只提供给HHTCPSocketTask使用 对外不可见
- (void)resumeTask:(HHTCPSocketTask *)task {

// 向Socket中写入Request格式化好的数据
if (self.socket.isConnected) {
[self.socket writeData:task.request.requestData];
} else {

NSError *error;
if (self.isNetworkReachable) {
error = HHError(HHNetworkErrorNotice, HHNetworkTaskErrorTimeOut);
} else {
error = HHError(HHNetworkErrorNotice, HHNetworkTaskErrorCannotConnectedToInternet);
}
[task completeWithResponseData:nil error:error];
}
}

@end

//HHTCPSocketTask.m

@interface HHTCPSocketTask ()

- (void)setClient:(id)client;//此接口仅提供给上面的HHTCPSocketClient使用 对外不可见

@end

//对外接口 调用方通过通过此接口发起Request
- (void)resume {
...其他逻辑 略

//通知client将task.request的数据写入Socket
[self.client resumeTask:self];
}

简单描述一下代码流程:

  1. 调用方提供Request和completionHandler回调从HHTCPSocketClient获得一个打包好的Task(通过dataTaskWithRequest:completionHandler:接口), HHTCPSocketClient内部会以(Request.serNum: Task)的形式将其保存在dispatchTable中.

  2. 调用方通过Task.resume发起TCP请求, 待收到服务端响应后HHTCPSocketClient会根据Response.serNum从dispatchTable取出Task然后执行调用方提供的completionHandler回调.(这里为了和系统的NSURLSessionTask保持一致的接口, 我给TCPClient和TCPTask加了一些辅助方法, 代码上绕了一个圈, 实际上, Task.resume就是Socket.writeData:Task.Request.Data).

处理请求响应

正常情况下, 请求发出后, 很快就就会收到服务端的响应二进制数据, 我们要做的就是, 从这些二进制数据中切割出单个Response报文, 然后一一进行分发. 代码如下:


//HHTCPSocketClient.m

@interface HHTCPSocketClient()<HHTCPSocketDelegate>

//保存所有收到的服务端数据 等待解析
@property (nonatomic, strong) NSMutableData *buffer;
...其他逻辑 略
@end

#pragma mark - HHTCPSocketDelegate

//从Socket从读取到数据
- (void)socket:(HHTCPSocket *)sock didReadData:(NSData *)data {
[self.buffer appendData:data]; //1\. 保存读取到的二进制数据

[self readBuffer];//2\. 根据协议解析二进制数据
}

#pragma mark - Parse

//递归截取Response报文 因为读取到的数据可能已经"粘包" 所以需要递归
- (void)readBuffer {
if (self.isReading) { return; }

self.isReading = YES;
NSData *responseData = [self getParsedResponseData];//1\. 从已读取到的二进制中截取单个Response报文数据
[self dispatchResponse:responseData];//2\. 将Response报文派发给对应的Task
self.isReading = NO;

if (responseData.length == 0) { return; }
[self readBuffer]; //3\. 递归解析
}

//根据定义的协议从buffer中截取出单个Response报文
- (NSData *)getParsedResponseData {

NSData *totalReceivedData = self.buffer;
//1\. 每个Response报文必有的16个字节(url+serNum+respCode+contentLen)
uint32_t responseHeaderLength = [HHTCPSocketResponseParser responseHeaderLength];
if (totalReceivedData.length < responseHeaderLength) { return nil; }

//2\. 根据定义的协议读取出Response.content的长度
NSData *responseData;
uint32_t responseContentLength = [HHTCPSocketResponseParser responseContentLengthFromData:totalReceivedData];
//3\. Response.content的长度加上必有的16个字节即为整个Response报文的长度
uint32_t responseLength = responseHeaderLength + responseContentLength;
if (totalReceivedData.length < responseLength) { return nil; }

//4\. 根据上面解析出的responseLength截取出单个Response报文
responseData = [totalReceivedData subdataWithRange:NSMakeRange(0, responseLength)];
self.buffer = [[totalReceivedData subdataWithRange:NSMakeRange(responseLength, totalReceivedData.length - responseLength)] mutableCopy];
return responseData;
}

//将Response报文解析Response 然后交由对应的Task进行派发
- (void)dispatchResponse:(NSData *)responseData {
HHTCPSocketResponse *response = [HHTCPSocketResponse responseWithData:responseData];
if (response == nil) { return; }

if (response.url > TCP_max_notification) {/** 请求响应 */

HHTCPSocketTask *task = self.dispatchTable[@(response.serNum)];
[task completeWithResponse:response error:nil];
} else {/** 推送或心跳 略 */
...
}
}

简单描述下代码流程:

  1. TCPClient监听Socket读取数据回调方法, 将读取到的服务端二进制数据添加到buffer中.

  2. 根据定义的协议从buffer头部开始, 不停地截取出单个Response报文, 直到buffer数据取无可取.

  3. 从2中截取到的Response报文中解析出Response.serNum, 根据serNum从dispatchTable中取出对应的Task(Response.serNum == Request.serNum), 将Response交付给Task. 至此, TCPClient的工作完成.

  4. Task拿到Response后通过completionHandler交付给调用方. 至此, 一次TCPTask完成.

这里需要注意的是, Socket的回调方法我这边默认都是在串行队列中执行的, 所以对buffer的操作并不没有加锁, 如果是在并行队列中执行Socket的回调, 请记得对buffer操作加锁.

处理后台推送

除了Request对应的Response, 服务端有时也会主动发送一些推送数据给客户端, 我们也需要处理一下:


//HHTCPSocketClient.m

- (void)dispatchResponse:(NSData *)responseData {
HHTCPSocketResponse *response = [HHTCPSocketResponse responseWithData:responseData];
if (response == nil) { return; }

if (response.url > TCP_max_notification) {/** 请求响应 略*/
//...
} else if (response.url == TCP_heatbeat) {/** 心跳 略 */
//...
} else {/** 推送 */
[self dispatchRemoteNotification:response];
}
}

//各种推送 自行处理
- (void)dispatchRemoteNotification:(HHTCPSocketResponse *)notification {

switch (notification.url) {
case TCP_notification_xxx: ...
case TCP_notification_yyy: ...
case TCP_notification_zzz: ...
default:break;
}
}

请求超时和取消

TCP协议的可靠性规定了数据会完整的, 有序的进行传输, 但并未规定数据传输的最大时长. 这意味着, 从发起Request到收到Response的时间间隔可能比我们能接受的时间间隔要长. 这里我们也简单处理一下, 代码如下:


//HHTCPSocketTask.m

#pragma mark - Interface

- (void)cancel {
if (![self canResponse]) { return; }

self.state = HHTCPSocketTaskStateCanceled;
[self completeWithResult:nil error:[self taskErrorWithResponeCode:HHNetworkTaskErrorCanceled]];
}

- (void)resume {
if (self.state != HHTCPSocketTaskStateSuspended) { return; }

//发起Request的同时也启动一个timer timer超时直接返回错误并忽略后续的Response
self.timer = [NSTimer scheduledTimerWithTimeInterval:self.request.timeoutInterval target:self selector:@selector(requestTimeout) userInfo:nil repeats:NO];
[[NSRunLoop mainRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];

self.state = HHTCPSocketTaskStateRunning;
[self.client resumeTask:self];
}

#pragma mark - Action

- (void)requestTimeout {
if (![self canResponse]) { return; }

self.state = HHTCPSocketTaskStateCompleted;
[self completeWithResult:nil error:[self taskErrorWithResponeCode:HHNetworkTaskErrorTimeOut]];
}

#pragma mark - Utils

- (BOOL)canResponse {
return self.state <= HHTCPSocketTaskStateRunning;
}

代码很简单, 只是在写入Task.Request的同时也开启一个timer, timer超时就直接忽略Response并返回错误给调用方而已. 对于类似HTTP的GET请求而言, 忽略和取消几乎是等价的. 但对于POST请求而言, 我们需要的可能就是直接断开连接了

心跳

目前为止, 我们已经有了一个简单的TCP客户端, 它可以发送数据请求, 接收数据响应, 还能处理服务端推送. 最后, 我们做一下收尾工作: 心跳

单向的心跳就不说了, 这里我们给到一张Ping-Pong的简易图:




当发送方为客户端时, Ping-Pong通常用来验证TCP连接的有效性. 具体来说, 如果Ping-Pong正常, 那么证明连接有效, 数据传输没有问题, 反之, 要么连接已断开, 要么连接还在但服务器已经过载无力进行恢复, 此时客户端可以选择断开重连或者切换服务器.

当发送方为服务端时, Ping-Pong通常用来验证数据传输的即时性. 具体来说, 当服务端向客户端发送一条即时性消息时通常还会马上Ping一下客户端, 如果客户端即时进行回应, 那么说明Ping之前的即时性消息已经到达, 反之, 消息不够即时, 服务端可能会走APNS再次发送该消息.

Demo中我简单实现了一下Ping-Pong, 代码如下:


//HHTCPSocketHeartbeat

static NSUInteger maxMissTime = 3;
@implementation HHTCPSocketHeartbeat

+ (instancetype)heartbeatWithClient:(id)client timeoutHandler:(void (^)(void))timeoutHandler {

HHTCPSocketHeartbeat *heartbeat = [HHTCPSocketHeartbeat new];
heartbeat.client = client;
heartbeat.missTime = -1;
heartbeat.timeoutHandler = timeoutHandler;
return heartbeat;
}

- (void)start {

[self stop];
self.timer = [NSTimer timerWithTimeInterval:60 target:self selector:@selector(sendHeatbeat) userInfo:nil repeats:YES];
[[NSRunLoop mainRunLoop] addTimer:self.timer forMode:NSRunLoopCommonModes];
}

- (void)stop {
[self.timer invalidate];
}

- (void)reset {
self.missTime = -1;
[self start];
}

- (void)sendHeatbeat {

self.missTime += 1;
if (self.missTime >= maxMissTime && self.timeoutHandler != nil) {//心跳超时 执行超时回调
self.timeoutHandler();
self.missTime = -1;
}

HHTCPSocketRequest *request = [HHTCPSocketRequest requestWithURL:TCP_heatbeat parameters:@{@"ackNum": @(TCP_heatbeat)} header:nil];
[self.client dispatchDataTaskWithRequest:request completionHandler:nil];
}

- (void)handleServerAckNum:(uint32_t)ackNum {
if (ackNum == TCP_heatbeat) {//服务端返回的心跳回应Pong 不用处理
self.missTime = -1;
return;
}

//服务端发起的Ping 需要回应
HHTCPSocketRequest *request = [HHTCPSocketRequest requestWithURL:TCP_heatbeat parameters:@{@"ackNum": @(ackNum)} header:nil];
[self.client dispatchDataTaskWithRequest:request completionHandler:nil];
}

@end

HHTCPSocketHeartbeat每隔一段时间就会发起一个serNum固定为1的心跳请求Ping一下服务端, 在超时时间间隔内当收到任何服务端回应, 我们认为连接有效, 心跳重置, 否则执行调用方设置的超时回调. 另外, HHTCPSocketHeartbeat还负责回应服务端发起的serNum为随机数的即时性Response(这里的随机数我给的是时间戳).

//HHTCPSocketClient.m

- (void)configuration {

self.heatbeat = [HHTCPSocketHeartbeat heartbeatWithClient:self timeoutHandler:^{//客户端心跳超时回调
// [self reconnect];
SocketLog(@"heartbeat timeout");
}];
}

#pragma mark - HHTCPSocketDelegate

- (void)socket:(HHTCPSocket *)sock didConnectToHost:(NSString *)host port:(uint16_t)port {
[self.heatbeat reset];//连接成功 客户端心跳启动
}

- (void)socketDidDisconnect:(HHTCPSocket *)sock error:(NSError *)error {
[self.heatbeat stop];//连接断开 客户端心跳停止
}

- (void)socket:(HHTCPSocket *)sock didReadData:(NSData *)data {
[self.heatbeat reset];//收到服务端数据 说明连接有效 重置心跳
//...其他 略
}

//获取到服务端Response
- (void)dispatchResponse:(NSData *)responseData {
HHTCPSocketResponse *response = [HHTCPSocketResponse responseWithData:responseData];
if (response == nil) { return; }

if (response.url == TCP_heatbeat) {/** 心跳 */
[self.heatbeat handleServerAckNum:response.serNum];//回复服务端心跳请求 如果有必要的话
}
}
文件下载/上传?

到目前为止, 我们讨论的都是类似DataTask的数据请求, 并未涉及到文件下载/上传请求, 事实上, 我也没打算在通讯协议上加上这两种请求的支持. 这部分我是这样考虑的:

如果传输的文件比较小, 那么仿照HTTP直接给协议加上ContentType字段, Content以特殊分隔符进行分隔即可.

如果传输的文件比较大, 那么直接在当前连接进行文件传输可能会阻塞其他的数据传输, 这是我们不希望看到的, 所以一定是另起一条连接专用于大文件传输. 考虑到文件传输不太可能像普通数据传输那样需要即时性和服务端推送, 为了节省服务端开销, 文件传输完成后连接也没有必要继续保持. 这里的"建立连接-文件传输-断开连接"其实已经由HTTP实现得很好了, 而且功能还多, 我们没必要再做重复工作.

基于以上考虑, 文件传输这块我更趋向于直接使用HTTP而不是自行实现.

至此, TCP部分的讨论就结束了.



作者:Cooci
链接:https://www.jianshu.com/p/c0df2690e9d4



收起阅读 »

iOS-TCP网络框架(一)

TCP概述TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议,由IETF的RFC793定义. 在因特网协议族中,TCP属于传输层, 位于网络层之上,应用层之下.需要注意的是, TCP只是协议声明, 仅对外声明协议提供的功能, 但本身并不进行任何实现. ...
继续阅读 »
TCP概述

TCP是一种面向连接的、可靠的、基于字节流的传输层通信协议,由IETF的RFC793定义. 在因特网协议族中,TCP属于传输层, 位于网络层之上,应用层之下.

需要注意的是, TCP只是协议声明, 仅对外声明协议提供的功能, 但本身并不进行任何实现. 因此, 在介绍通信协议时, 通常我们还会提及另一个术语: Socket.
Socket并不是一种协议, 而是一组接口(即API). 协议的实现方通过Socket对外提供具体的功能调用. TCP协议的实现方提供的接口就是TCPSocket, UDP协议的实现方提供的接口就是UDPSocket...

通常, 协议的使用方并不直接面对协议的实现方, 而是通过对应的Socket使用协议提供的功能. 因此, 即使以后协议的底层实现进行了任何改动, 但由于对外的接口Socket不变, 使用方也不需要做出任何变更.

TCP协议基于IP协议, 而IP协议属于不可靠协议, 要在一个不可靠协议的的基础上实现一个可靠的数据传输协议是困难且复杂的, TCP的定义者也并不指望所有程序员都能自行实现一遍TCP协议. 所以, 与其说本文是在介绍TCP编程, 倒不如说是介绍TCPSocket编程.

建立通讯连接

通过Socket建立TCP连接是非常简单的, 连接方(客户端)只需要提供被连接方(服务端)的IP地址和端口号去调用连接接口即可, 被连接方接受连接的话, 接口会返回成功, 否则返回失败, 至于底层的握手细节, 双方完全不用关心. 但考虑到网络波动, 前后台切换, 服务器重启等等可能导致的连接主动/被动断开的情况, 客户端这边我会加上必要的重连处理. 主要代码如下:


//HHTCPSocket.h

@class HHTCPSocket;
@protocol HHTCPSocketDelegate <NSObject>

@optional
- (void)socket:(HHTCPSocket *)sock didConnectToHost:(NSString *)host port:(uint16_t)port; //连接成功

- (void)socketCanNotConnectToService:(HHTCPSocket *)sock; //重连失败
- (void)socketDidDisconnect:(HHTCPSocket *)sock error:(NSError *)error; //连接失败并开始重连

@end

@interface HHTCPSocket : NSObject

@property (nonatomic, weak) id<HHTCPSocketDelegate> delegate;
@property (nonatomic, assign) NSUInteger maxRetryTime; //最大重连次数

- (instancetype)initWithService:(HHTCPSocketService *)service; //service提供ip地址和端口号

- (void)close;
- (void)connect; //连接
- (void)reconnect; //重连
- (BOOL)isConnected;

@end

//HHTCPSocket.m

@implementation HHTCPSocket

- (instancetype)initWithService:(HHTCPSocketService *)service {
if (self = [super init]) {
self.service = service ?: [HHTCPSocketService defaultService];

//1\. 初始化Socket
const char *delegateQueueLabel = [[NSString stringWithFormat:@"%p_socketDelegateQueue", self] cStringUsingEncoding:NSUTF8StringEncoding];
self.reconnectTime = self.maxRetryTime;
self.delegateQueue = dispatch_queue_create(delegateQueueLabel, DISPATCH_QUEUE_SERIAL);
self.socket = [[GCDAsyncSocket alloc] initWithDelegate:self delegateQueue:self.delegateQueue];

//2\. 初始化Socket连接线程
self.machPort = [NSMachPort port];
self.keepRuning = YES;
self.socket.IPv4PreferredOverIPv6 = NO; //支持ipv6
[NSThread detachNewThreadSelector:@selector(configSocketThread) toTarget:self withObject:nil];

//3\. 处理网络波动/前后台切换
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceivedNetworkChangedNotification:) name:kRealReachabilityChangedNotification object:nil];
[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(didReceivedAppBecomeActiveNotification:) name:UIApplicationDidBecomeActiveNotification object:nil];
}
return self;
}

- (void)dealloc {
[[NSNotificationCenter defaultCenter] removeObserver:self];
}

#pragma mark - Interface

- (void)connect {
if (self.isConnecting || !self.isNetworkReachable) { return; }
self.isConnecting = YES;

[self disconnect];

//去Socket连接线程进行连接 避免阻塞UI
BOOL isFirstTimeConnect = (self.reconnectTime == self.maxRetryTime);
int64_t delayTime = isFirstTimeConnect ? 0 : (arc4random() % 3) + 1;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayTime * NSEC_PER_SEC)), dispatch_get_global_queue(2, 0), ^{
[self performSelector:@selector(connectOnSocketThread) onThread:self.socketThread withObject:nil waitUntilDone:YES];
});
}

- (void)reconnect {

self.reconnectTime = self.maxRetryTime;
[self connect];
}

- (void)disconnect {
if (!self.socket.isConnected) { return; }

[self.socket setDelegate:nil delegateQueue:nil];
[self.socket disconnect];
}

- (BOOL)isConnected {
return self.socket.isConnected;
}

#pragma mark - GCDAsyncSocketDelegate

- (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(uint16_t)port {
//连接成功 通知代理方
if ([self.delegate respondsToSelector:@selector(socket:didConnectToHost:port:)]) {
[self.delegate socket:self didConnectToHost:host port:port];
}

self.reconnectTime = self.maxRetryTime;
}

- (void)socketDidDisconnect:(GCDAsyncSocket *)sock withError:(NSError *)error {

if ([self.delegate respondsToSelector:@selector(socketDidDisconnect:error:)]) {
[self.delegate socketDidDisconnect:self error:error];
}
[self tryToReconnect];//连接失败 尝试重连
}

#pragma mark - Action

- (void)configSocketThread {

if (self.socketThread == nil) {
self.socketThread = [NSThread currentThread];
[[NSRunLoop currentRunLoop] addPort:self.machPort forMode:NSDefaultRunLoopMode];
}
while (self.keepRuning) {
[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantFuture]];
}

[[NSRunLoop currentRunLoop] removePort:self.machPort forMode:NSDefaultRunLoopMode];
[[NSRunLoop currentRunLoop] runMode:NSDefaultRunLoopMode beforeDate:[NSDate distantPast]];
[self.socketThread cancel];
self.socket = nil;
self.machPort = nil;
self.socketThread = nil;
self.delegateQueue = nil;
}

- (void)connectOnSocketThread {//实际的调用连接操作在这里

[self.socket setDelegate:self delegateQueue:self.delegateQueue];
[self.socket connectToHost:self.service.host onPort:self.service.port error:nil];
self.isConnecting = NO;
}

#pragma mark - Notification

- (void)didReceivedNetworkChangedNotification:(NSNotification *)notif {
[self reconnectIfNeed];
}

- (void)didReceivedAppBecomeActiveNotification:(NSNotification *)notif {
[self reconnectIfNeed];
}

#pragma mark - Utils

- (void)tryToReconnect {
if (self.isConnecting || !self.isNetworkReachable) { return; }

self.reconnectTime -= 1;
if (self.reconnectTime >= 0) {
[self connect];
} else if ([self.delegate respondsToSelector:@selector(socketCanNotConnectToService:)]) {
[self.delegate socketCanNotConnectToService:self];
}
}

- (NSUInteger)maxRetryTime {
return _maxRetryTime > 0 ? _maxRetryTime : 5;
}

@end

这边因为需要添加重连操作, 所以我在GCDAsyncSocket的基础上又封装了一下, 但总体代码不多, 应该比较好理解. 这里需要注意的是GCDAsyncSocket的连接接口(connectToHost: onPort: error:)是同步调用的, 慢网情况下可能会阻塞线程一段时间, 所以这里我单开了一个线程来做连接操作.

连接建立以后, 就可以读写数据了, 写数据的接口如下:


- (void)writeData:(NSData *)data {
if (!self.isConnected || data.length == 0) { return; }

[self.socket writeData:data withTimeout:-1 tag:socketTag];
}

 //连接成功...
while (1) {

Error *error;
Data *readData = [socket readToLength:1024 error:&error];//同步 读不到数据就阻塞
if (error) { return; }

[self handleData:readData];//同步异步皆可 多为异步
}

具体到我们的代码中, 则是这个样子:
// HHTCPSocket.h

@protocol HHTCPSocketDelegate <NSObject>
//...其他回调方法
- (void)socket:(HHTCPSocket *)sock didReadData:(NSData *)data;//读取到数据回调方法
@end

// HHTCPSocket.m

- (void)socket:(GCDAsyncSocket *)sock didConnectToHost:(NSString *)host port:(uint16_t)port {
//Socket连接成功 开始读数据
[self.socket readDataWithTimeout:-1 tag:socketTag];
}

- (void)socket:(GCDAsyncSocket *)sock didWriteDataWithTag:(long)tag {
//Socket写数据成功 继续读取数据
[self.socket readDataWithTimeout:-1 tag:socketTag];
}

- (void)socket:(GCDAsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag {

//从Socket中读到数据 交由调用方处理
if ([self.delegate respondsToSelector:@selector(socket:didReadData:)]) {
[self.delegate socket:self didReadData:data];
}
[self.socket readDataWithTimeout:-1 tag:socketTag];//继续读取数据
}

现在我们已经可以通过Socket建立一条会自动重连的TCP连接, 然后还可以通过Socket从连接中读写数据, 接下来要做的就是定义一套自己的通讯协议了.

定义通讯协议
  • 为什么需要定义通讯协议

TCP协议定义了连接双方以字节流而不是报文段的方式进行数据传输, 这意味着任何应用层报文(image/text/html...)想要通过TCP进行传输都必须先转化成二进制数据. 另外, TCP实现出于传输效率考虑, 往往会在连接两端各自开辟一个发送数据缓冲区和一个接收数据缓冲区. 因此, 有时应用层通过Socket向连接中写入数据时, 数据其实并没有立即被发送, 而是被放入缓冲区等待合适的时机才会真正的发送. 理想情况下, TCP进行传输数据的流程可能像这样:




但实际情况中, 因为Nagle算法/网络拥堵/拥塞控制/接收方读取太慢等等各种原因, 数据很有可能会在发送缓冲区/接收缓冲区被累积. 所以, 上面的流程更可能是这样:




或者这样:




上面的图都假设应用层报文不到一个MSS(一个MSS一般为1460字节, 这对大部分非文件请求来说都足够了), 当报文超过一个MSS时, TCP底层实现会对报文进行拆分后多次传输, 这会稍微复杂些(不想画图了), 但最后导致的问题是一致的, 解决方案也是一致的.

从上面的图容易看出, 无论数据在发送缓冲区还是接收缓冲区被累积, 对于接收方程序来说都是一样的: 多个应用层报文不分彼此粘作一串导致数据无法还原(粘包).

得益于TCP协议是可靠的传输协议(可靠意味着TCP实现会保证数据不会丢包, 也不会乱序), 粘包的问题很好处理. 我们只需要在发送方给每段数据都附上一份描述信息(描述信息主要包括数据的长度, 解析格式等等), 接收方就可以根据描述信息从一串数据流中分割出单独的每段应用层报文了.

被传输数据和数据的描述一起构成了一段应用层报文, 这里我们称实际想传输的数据为报文有效载荷, 而数据的描述信息为报文头部. 此时, 数据的传输流程就成了这样:




  • 定义一个简单的通讯协议

自定义通讯协议时, 往往和项目业务直接挂钩, 所以这块其实没什么好写的. 但为了继续接下来的讨论, 这里我会给到一个非常简单的Demo版协议, 它长这样:


因为客户端和服务端都可以发送和接收数据, 为了方便描述, 这里我们对客户端发出的报文统一称为Request, 服务端发出的报文统一称为Response.

这里需要注意的是, 这里的Request和Response并不总是一一对应, 比如客户端单向的心跳请求报文服务端是不会响应的, 而服务端主动发出的推送报文也不是客户端请求的.

Request由4个部分组成:

  1. url: 类似HTTP中的统一资源定位符, 32位无符号整数(4个字节). 用于标识客户端请求的服务端资源或对资源进行的操作. 由服务端定义, 客户端使用.

  2. content(可选): 请求携带的数据, 0~N字节的二进制数据. 用于携带请求传输的内容, 传输的内容目前是请求参数, 也可能什么都没有. 解析格式固定为JSON.

  3. serNum: 请求序列号, 32位无符号整数(4个字节). 用于标示请求本身, 每个请求对应一个唯一的序列号, 即使两个请求的url和content都相同. 由客户端生成并传输, 服务端解析并回传. 客户端通过回传的序列号和请求序列号之间的对应关系进行响应数据分发.

  4. contentLen: 请求携带数据长度, 32位无符号整数(4个字节). 用于标示请求携带的数据的长度. 服务端通过contentLen将粘包的数据进行切割后一一解析并处理.

Response由5个部分组成:

  1. url: 同Request.

  2. respCode: 类似HTTP状态码, 32位无符号整数(4个字节).

  3. content(可选): 响应携带的数据, 0~N字节的二进制数据. 携带的数据可能是某个Request的响应数据, 也可能是服务端主动发出的推送数据, 或者, 什么都没有. 解析格式固定为JSON.

  4. serNum: 该Response所对应的Request序列号, 32位无符号整数(4个字节). 若Response并没有对应的Request(比如推送), Response.serNum==Response.url.

  5. contentLen: Response携带的数据长度, 32位无符号整数(4个字节). 用于标示Response携带的数据的长度. 客户端通过contentLen将粘包的数据进行切割后一一解析并处理.

因为只是Demo用, 这个协议会比较随意. 但在实际开发中, 我们应该尽量参考那些成熟的应用层协议(HTTP/FTP...). 比如考虑到后续的业务变更, 应该加上Version字段. 加上ContentType字段以传输其他类型的数据, 压缩字段字节数以节省流量...等等.


实现通讯协议

有了协议以后, 就可以写代码进行实现了. Request部分主要代码如下:

//HHTCPSocketRequest.h

/** URL类型肯定都是后台定义的 直接copy过来即可 命名用后台的 方便调试时比对 */
typedef enum : NSUInteger {
TCP_heatbeat = 0x00000001,
TCP_notification_xxx = 0x00000002,
TCP_notification_yyy = 0x00000003,
TCP_notification_zzz = 0x00000004,

/* ========== */
TCP_max_notification = 0x00000400,
/* ========== */

TCP_login = 0x00000401,
TCP_weibo_list_public = 0x00000402,
TCP_weibo_list_followed = 0x00000403,
TCP_weibo_like = 0x00000404
} HHTCPSocketRequestURL;

+ (instancetype)requestWithURL:(HHTCPSocketRequestURL)url parameters:(NSDictionary *)parameters header:(NSDictionary *)header;


//HHTCPSocketRequest.m

+ (instancetype)requestWithURL:(HHTCPSocketRequestURL)url parameters:(NSDictionary *)parameters header:(NSDictionary *)header {

NSData *content = [parameters yy_modelToJSONData];
uint32_t requestIdentifier = [self currentRequestIdentifier];

HHTCPSocketRequest *request = [HHTCPSocketRequest new];
request.requestIdentifier = @(requestIdentifier);
[request.formattedData appendData:[HHDataFormatter msgTypeDataFromInteger:url]];/** 请求URL */
[request.formattedData appendData:[HHDataFormatter msgSerialNumberDataFromInteger:requestIdentifier]];/** 请求序列号 */
[request.formattedData appendData:[HHDataFormatter msgContentLengthDataFromInteger:(uint32_t)content.length]];/** 请求内容长度 */

if (content != nil) { [request.formattedData appendData:content]; }/** 请求内容 */
return request;
}

+ (uint32_t)currentRequestIdentifier {

static uint32_t currentRequestIdentifier;
static dispatch_semaphore_t lock;
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{

currentRequestIdentifier = TCP_max_notification;
lock = dispatch_semaphore_create(1);
});

dispatch_semaphore_wait(lock, DISPATCH_TIME_FOREVER);
if (currentRequestIdentifier + 1 == 0xffffffff) {
currentRequestIdentifier = TCP_max_notification;
}
currentRequestIdentifier += 1;
dispatch_semaphore_signal(lock);

return currentRequestIdentifier;
}


HHTCPSocketRequest主要做两件事: 1.为每个Request生成唯一序列号; 2. 根据协议定义将应用层数据转化为相应的二进制数据.

应用层数据和二进制数据间的转化由HHDataFormatter完成, 它负责统一数据格式化接口和大小端问题

接下来是Response部分的代码:

//HHTCPSocketResponse.h

@interface HHTCPSocketResponse : NSObject

+ (instancetype)responseWithData:(NSData *)data;

- (HHTCPSocketRequestURL)url;

- (NSData *)content;
- (uint32_t)serNum;
- (uint32_t)statusCode;
@end

//HHTCPSocketResponse.m

+ (instancetype)responseWithData:(NSData *)data {
if (data.length < [HHTCPSocketResponseParser responseHeaderLength]) {
return nil;
}

HHTCPSocketResponse *response = [HHTCPSocketResponse new];
response.data = data;
return response;
}

- (HHTCPSocketRequestURL)url {
if (_url == 0) {
_url = [HHTCPSocketResponseParser responseURLFromData:self.data];
}
return _url;
}

- (uint32_t)serNum {
if (_serNum == 0) {
_serNum = [HHTCPSocketResponseParser responseSerialNumberFromData:self.data];
}
return _serNum;
}

- (uint32_t)statusCode {
if (_statusCode == 0) {
_statusCode = [HHTCPSocketResponseParser responseCodeFromData:self.data];
}
return _statusCode;
}

- (NSData *)content {
return [HHTCPSocketResponseParser responseContentFromData:self.data];
}

@end

HHTCPSocketResponse比较简单, 它只做一件事: 根据协议定义将服务端返回的二进制数据解析为应用层数据.

最后, 为了方便管理, 我们再抽象出一个Task. Task将负责请求状态, 请求超时, 请求回调等等的管理. 这部分和协议无关, 但很有必要.
Task部分的代码如下:


//HHTCPSocketTask.h

typedef enum : NSUInteger {
HHTCPSocketTaskStateSuspended = 0,
HHTCPSocketTaskStateRunning = 1,
HHTCPSocketTaskStateCanceled = 2,
HHTCPSocketTaskStateCompleted = 3
} HHTCPSocketTaskState;

@interface HHTCPSocketTask : NSObject

- (void)cancel;
- (void)resume;

- (HHTCPSocketTaskState)state;
- (NSNumber *)taskIdentifier;

@end

//HHTCPSocketTask.m

//保存Request和completionHandler Request用于将调用方数据写入Socket completionHandler用于将Response交付给调用方
+ (instancetype)taskWithRequest:(HHTCPSocketRequest *)request completionHandler:(HHNetworkTaskCompletionHander)completionHandler {

HHTCPSocketTask *task = [HHTCPSocketTask new];
task.request = request;
task.completionHandler = completionHandler;
task.state = HHTCPSocketTaskStateSuspended;
...其他 略
return task;
}

//处理服务端返回的Response Socket读取到相应的Response报文数据后会调用此接口
- (void)completeWithResponse:(HHTCPSocketResponse *)response error:(NSError *)error {
if (![self canResponse]) { return; }

NSDictionary *result;
if (error == nil) {

if (response == nil) {
error = [self taskErrorWithResponeCode:HHTCPSocketResponseCodeUnkonwn];
} else {

error = [self taskErrorWithResponeCode:response.statusCode];
result = [NSJSONSerialization JSONObjectWithData:response.content options:0 error:nil];
}
}

[self completeWithResult:result error:error];
}

//将处理后的数据交付给调用方
- (void)completeWithResult:(id)result error:(NSError *)error {

...其他 略
dispatch_async(dispatch_get_main_queue(), ^{

!self.completionHandler ?: self.completionHandler(error, result);
self.completionHandler = nil;
});
}



作者:Cooci
链接:https://www.jianshu.com/p/c0df2690e9d4





收起阅读 »

前端面试常问的基础(二)

1. 一个程序至少有一个进程,一个进程至少有一个线程2. 线程的划分尺度小于进程,使得多线程程序的并发性高3. 另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率4. 线程在执行过程中与进程还是有区别的。每个独立的线程...
继续阅读 »

1. 一个程序至少有一个进程,一个进程至少有一个线程

2. 线程的划分尺度小于进程,使得多线程程序的并发性高

3. 另外,进程在执行过程中拥有独立的内存单元,而多个线程共享内存,从而极大地提高了程序的运行效率

4. 线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行,必须依存在应用程序中,由应用程序提供多个线程执行控制 

5. 从逻辑角度来看,多线程的意义在于一个应用程序中,有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用,来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别

------------

1.IE6或更低版本最多20个cookie

2.IE7和之后的版本最后可以有50个cookie。

3.Firefox最多50个cookie

4.chrome和Safari没有做硬性限制

IE和Opera 会清理近期最少使用的cookie,Firefox会随机清理cookie。


优点:极高的扩展性和可用性


1.通过良好的编程,控制保存在cookie中的session对象的大小。

2.通过加密和安全传输技术(SSL),减少cookie被破解的可能性。

3.只在cookie中存放不敏感数据,即使被盗也不会有重大损失。

4.控制cookie的生命期,使之不会永远有效。偷盗者很可能拿到一个过期的cookie。


缺点:

1.`Cookie`数量和长度的限制。每个domain最多只能有20条cookie,每个cookie长度不能超过4KB,否则会被截掉。


2.安全性问题。如果cookie被人拦截了,那人就可以取得所有的session信息。即使加密也与事无补,因为拦截者并不需要知道cookie的意义,他只要原样转发cookie就可以达到目的了。


3.有些状态不可能保存在客户端。例如,为了防止重复提交表单,我们需要在服务器端保存一个计数器。如果我们把这个计数器保存在客户端,那么它起不到任何作用。


本文链接:https://blog.csdn.net/kincaid_z/article/details/116530326

待完善

收起阅读 »

前端面试常问的基础(一)

 IE 盒子模型、标准 W3C 盒子模型;IE的content部分包含了 border 和 padding;new操作符具体干了什么呢?1. 创建一个空对象,并且 this 变量引用该对象,同时还继承了该函数的原型2. 属性和方法被加入到 this ...
继续阅读 »

 IE 盒子模型、标准 W3C 盒子模型;IE的content部分包含了 border 和 padding;


new操作符具体干了什么呢?

1. 创建一个空对象,并且 this 变量引用该对象,同时还继承了该函数的原型

2. 属性和方法被加入到 this 引用的对象中

3. 新创建的对象由 this 所引用,并且最后隐式的返回 this


JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。它是基于JavaScript的一个子集。数据格式简单, 易于读写, 占用带宽小


内存泄漏指任何对象在您不再拥有或需要它之后仍然存在。

垃圾回收器定期扫描对象,并计算引用了每个对象的其他对象的数量。如果一个对象的引用数量为 0(没有其他对象引用过该对象),或对该对象的惟一引用是循环的,那么该对象的内存即可回收。

1. setTimeout 的第一个参数使用字符串而非函数的话,会引发内存泄漏。

2. 闭包

3. 控制台日志

4. 循环(在两个对象彼此引用且彼此保留时,就会产生一个循环)


一个页面从输入 URL 到页面加载显示完成,这个过程中都发生了什么?

分为4个步骤:

1. 当发送一个 URL 请求时,不管这个 URL 是 Web 页面的 URL 还是 Web 页面上每个资源的 URL,浏览器都会开启一个线程来处理这个请求,同时在远程 DNS 服务器上启动一个 DNS 查询。这能使浏览器获得请求对应的 IP 地址。

2. 浏览器与远程 Web 服务器通过 TCP 三次握手协商来建立一个 TCP/IP 连接。该握手包括一个同步报文,一个同步-应答报文和一个应答报文,这三个报文在 浏览器和服务器之间传递。该握手首先由客户端尝试建立起通信,而后服务器应答并接受客户端的请求,最后由客户端发出该请求已经被接受的报文。

3. 一旦 TCP/IP 连接建立,浏览器会通过该连接向远程服务器发送 HTTP 的 GET 请求。远程服务器找到资源并使用 HTTP 响应返回该资源,值为 200 的 HTTP 响应状态表示一个正确的响应。

4. 此时,Web 服务器提供资源服务,客户端开始下载资源。


GET:一般用于信息获取,使用URL传递参数,对所发送信息的数量也有限制,一般在2000个字符

POST:一般用于修改服务器上的资源,对所发送的信息没有限制


Ajax 同步和异步的区别:

1. 同步:提交请求 -> 等待服务器处理 -> 处理完毕返回,这个期间客户端浏览器不能干任何事

2. 异步:请求通过事件触发 -> 服务器处理(这是浏览器仍然可以作其他事情)-> 处理完毕


js数组去重

[1,1,2,2,3,3,3,3].filter(function(elem, index, self) {

///结果是true的时候返回后面的值

    return index == self.indexOf(elem);

})


1. XSS

2. sql注入

3. CSRF:是跨站请求伪造,很明显根据刚刚的解释,他的核心也就是请求伪造,通过伪造身份提交POST和GET请求来进行跨域的攻击


完成CSRF需要两个步骤:

1. 登陆受信任的网站A,在本地生成 COOKIE

2. 在不登出A的情况下,或者本地 COOKIE 没有过期的情况下,访问危险网站B。



2.HTTP 报文的组成部分

请求报文

1.请求行:http方法、页面地址、协议、版本

2.请求头:key、value告诉服务端需要内容,注意什么类型

3.空行:告诉服务端请求头已经结束

4.请求体

响应报文

1.状态行:协议、版本、状态码

2.响应头

3.空行

4.响应体:文档部分


  • TCP/IP 四层协议: 应用层、传输层、网络互连层和主机到网络层. http对应应用层
  • ISO 七层模型: 物理层, 数据链路层, 网络层, 传输层, 会话层, 表示层, 应用层.  http对应应用



流行的一些东西:

1. Node.js

2. Mongodb

3. npm

4. MVVM

5. MEAN

6. three.js

7. React

本文链接:https://blog.csdn.net/kincaid_z/article/details/116530326


收起阅读 »

解决js精度丢失办法

很简单一个问题,0.1+0.2,我们肉眼可见的算出来等于0.3,但js是一个神奇的语言,我们在控制台输入0.1+0.2等于0.30000000000000004,为什么会这样尼,我百度了了一下,原因如下:JavaScript 中所有数字包括整数和小数都只有一种...
继续阅读 »

很简单一个问题,0.1+0.2,我们肉眼可见的算出来等于0.3,但js是一个神奇的语言,我们在控制台输入0.1+0.2等于0.30000000000000004,为什么会这样尼,我百度了了一下,原因如下:

JavaScript 中所有数字包括整数和小数都只有一种类型 — Number。它的实现遵循 IEEE 754 标准,使用 64 位固定长度来表示,也就是标准的 double 双精度浮点数(相关的还有float 32位单精度)。0.1的二进制表示的是一个无限循环小数,该版本的 JS 采用的是浮点数标准需要对这种无限循环的二进制进行截取,从而导致了精度丢失,造成了0.1不再是0.1,截取之后0.1变成了 0.100…001,0.2变成了0.200…002。所以两者相加的数大于0.3。

原因就是这么个奇葩,做需求的时候涉及到数字计算,那就得解决它老人家这个毛病,解决这个问题,我一般会封装成一个文件,到后面需要的地方可以模块化引入,并使用

1.判断obj是否为一个整数

export const  isInteger = (obj) => {
return Math.floor(obj) === obj //向下取整就是为了让整数部分截取下来不变
}

2.将一个浮点数转成整数,返回整数和倍数

比如:3.14 -->314,倍数是 100 ,floatNum {number} 小数,返回一个对象, {times:100, num: 314}

export const toInteger = (floatNum) => {
var ret = {times: 1, num: 0};
if (isInteger(floatNum)) {
ret.num = floatNum;
return ret
}
//1.//转字符串
var strfi = floatNum + '';
//2.//拿到小数点为
var dotPos = strfi.indexOf('.');
//3. //截取需要的长度
var len = strfi.substr(dotPos + 1).length;
//4.倍数就是长度的幂
var times = Math.pow(10, len);
var intNum = parseInt(floatNum * times , 10);
ret.times = times;
ret.num = intNum;
return ret
}

3.把小数放大为整数(乘),进行算术运算,再缩小为小数(除)

  1. 参数:a {number} 运算数1
  2. b:{number} 运算数2,
  3. op {string} 运算类型,有加减乘除(add/subtract/multiply/divide)
export const operation = (a, b, op) => {
var o1 = toInteger(a);
var o2 = toInteger(b);
var n1 = o1.num;
var n2 = o2.num;
var t1 = o1.times;
var t2 = o2.times;
var max = t1 > t2 ? t1 : t2;
var result = null;
switch (op) {
case 'add':
if (t1 === t2) { // 两个小数位数相同
result = n1 + n2
} else if (t1 > t2) { // o1 小数位 大于 o2
result = n1 + n2 * (t1 / t2)
} else { // o1 小数位 小于 o2
result = n1 * (t2 / t1) + n2
}
return result / max;
case 'subtract':
if (t1 === t2) {
result = n1 - n2
} else if (t1 > t2) {
result = n1 - n2 * (t1 / t2)
} else {
result = n1 * (t2 / t1) - n2
}
return result / max;
case 'multiply':
result = (n1 * n2) / (t1 * t2);
return result;
case 'divide':
result = (n1 / n2) * (t2 / t1);
return result
}
}

原文:https://segmentfault.com/a/1190000022730047

收起阅读 »

drawable用Kotlin应该这样写

Kotlin应该这样写系列 SharedPreferences用Kotlin应该这样写 Glide用Kotlin应该这样封装(一) Glide用Kotlin应该这样封装(二) 前言 通常我们在res/drawable下面自定义shape和selector来满足...
继续阅读 »

Kotlin应该这样写系列


SharedPreferences用Kotlin应该这样写


Glide用Kotlin应该这样封装(一)


Glide用Kotlin应该这样封装(二)


前言


通常我们在res/drawable下面自定义shapeselector来满足一些UI的设计,但是由于xml最终转换为drawable需要经过IO或反射创建,会有一些性能损耗,另外随着项目的增大和模块化等,很多通用的样式并不能快速复用,需要合理的项目资源管理规范才能实施。那么通过代码直接创建这些drawable,可以在一定程度上降低这些副作用。本篇介绍用kotlin DSL简洁的语法特性来实现常见的drawable.


代码对应效果预览


shape_line
RECTANGLE
OVAL
LayerList
Selector

集成和使用



  1. 在项目级的build.gradle文件种添加仓库Jitpack:


allprojects {
repositories {
...
maven { url 'https://jitpack.io' }
}
}
复制代码


  1. 添加依赖


dependencies {		
implementation 'com.github.forJrking:DrawableDsl:0.0.3’
}
复制代码


  1. 抛弃xml创建方式示例(其他参见demo)


// infix用法用于去掉括号更加简洁,详细后面说明
image src shapeDrawable {
//指定shape样式
shape(ShapeBuilder.Shape.RECTANGLE)
//圆角,支持4个角单独设置
corner(20f)
//solid 颜色
solid("#ABE2E3")
//stroke 颜色,边框dp,虚线设置
stroke(R.color.white, 2f, 5f, 8f)
}
//按钮点击样式
btn.background = selectorDrawable {
//默认样式
normal = shapeDrawable {
corner(20f)
gradient(90, R.color.F97794, R.color.C623AA2)
}
//点击效果
pressed = shapeDrawable {
corner(20f)
solid("#84232323")
}
}
复制代码

实现思路


xml如何转换成drawable


xml变成drawable,通过android.graphics.drawable.DrawableInflater这个类来IO解析标签创建,然后通过解析标签再设置属性:


//标签创建
private Drawable inflateFromTag(@NonNull String name) {
switch (name) {
case "selector":
return new StateListDrawable();
case "level-list":
return new LevelListDrawable();
case "layer-list":
return new LayerDrawable();
....
case "color":
return new ColorDrawable();
case "shape":
return new GradientDrawable();
case "vector":
return new VectorDrawable();
...
}
}
//反射创建
private Drawable inflateFromClass(@NonNull String className) {
try {
Constructor<? extends Drawable> constructor;
synchronized (CONSTRUCTOR_MAP) {
constructor = CONSTRUCTOR_MAP.get(className);
if (constructor == null) {
final Class<? extends Drawable> clazz = mClassLoader.loadClass(className).asSubclass(Drawable.class);
constructor = clazz.getConstructor();
CONSTRUCTOR_MAP.put(className, constructor);
}
}
return constructor.newInstance();
} catch (NoSuchMethodException e) {
...
}
复制代码

代码实现


由于创建shape等需要设置各种属性来构建,比较符合build设计模式,那我们首先封装build模式的shapeBuilder,这样做虽然代码比起直接使用apply{}要多,但是可以让纯java项目用起来很舒服,其他实现请查看源码:


class ShapeBuilder : DrawableBuilder {
private var mRadius = 0f
private var mWidth = 0f
private var mHeight = 0f
...
private var mShape = GradientDrawable.RECTANGLE
private var mSolidColor = 0

/**分别设置四个角的圆角*/
fun corner(leftTop: Float,rightTop: Float,leftBottom: Float,rightBottom: Float): ShapeBuilder {
....if(dp)dp2px(leftTop) else leftTop
return this
}

fun solid(@ColorRes colorId: Int): ShapeBuilder {
mSolidColor = ContextCompat.getColor(context, colorId)
return this
}
// 省略其他参数设置方法 详细代码查看源码
override fun build(): Drawable {
val gradientDrawable = GradientDrawable()
gradientDrawable = GradientDrawable()
gradientDrawable.setColor(mSolidColor)
gradientDrawable.shape = mShape
....其他参数设置
return gradientDrawable
}
}
复制代码

把build模式转换为dsl


理论上所有的build模式都可以轻松转换为dsl写法:


inline fun shapeDrawable(builder: ShapeBuilder.() -> Unit): Drawable {
return ShapeBuilder().also(builder).build()
}
//使用方法
val drawable = shapeDrawable{
...
}
复制代码

备注:dsl用法参见juejin.cn/post/695318… 中dsl小节


函数去括号


通过上面封装已经实现了dsl的写法,通常setBackground可以通过setter简化,但是我发现由于有些api设计还需要加括号,这样不太kotlin:


//容易阅读
iv1.background = shapeDrawable {
shape(ShapeBuilder.Shape.RECTANGLE)
solid("#ABE2E3")
}
//多了括号看起来不舒服
iv2.setImageDrawable(shapeDrawable {
solid("#84232323")
})
复制代码

怎么去掉括号呢?🈶2种方式infix函数(中缀表达)和property setter



  1. infix函数特点和规范:



  • Kotlin允许在不使用括号和点号的情况下调用函数

  • 必须只有一个参数

  • 必须是成员函数或扩展函数

  • 不支持可变参数和带默认值参数


/**为所有ImageView添加扩展infix函数 来去掉括号*/
infix fun ImageView.src(drawable: Drawable?) {
this.setImageDrawable(drawable)
}
//使用如下
iv2 src shapeDrawable {
shape(ShapeBuilder.Shape.OVAL)
solid("#E3ABC2")
}
复制代码

当然了代码是用来阅读的。个人认为如果我们大量使用infix函数,阅读困难会大大增加,所以建议函数命名必须可以直击函数功能,而且函数功能简单且单一。



  1. property setter方式,主要使用kotlin可以简化setter变量 =来去括号:


/**扩展变量*/
var ImageView.src: Drawable
get() = drawable
set(value) {
this.setImageDrawable(value)
}
//使用如下
iv2.src = shapeDrawable {
shape(ShapeBuilder.Shape.OVAL)
solid("#E3ABC2")
}
复制代码

感谢@叮凛凛 指点,欢迎大家讨论一起学习,共同进步。


优缺点


优点:



  • 代码直接创建比起xml方式可以提升性能

  • dsl方式比起build模式和调用方法设置更加简洁符合kotlin风格

  • 通过合适的代码管理可以复用这些代码,比xml管理方便


缺点:



  • 没有as的预览功能,只有通过上机观测

  • api还没有覆盖所有drawable属性(例如shape = ring等)


后语


上面把的DrawableDsl基础用法介绍完了,欢迎大家使用,欢迎提Issues,记得给个star哦。Github链接:github.com/forJrking/D…


作者:forJrking
链接:https://juejin.cn/post/6953472037012635655
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。
收起阅读 »

Kotlin 高效解析数学表达式(支持函数)

需求 由于项目需求,需要在低性能设备高频率地解析计算数学表达式,所以重量级的比如词法分析,语法分析,抽象语法树🌲三件套就不太合适了。(当然也不是不行,只是有点大材小用,而个人能力又有限,对于ANTLR调优之类不太擅长) 说起数学公式解析,当然离不开老朋友逆波兰...
继续阅读 »

需求


由于项目需求,需要在低性能设备高频率地解析计算数学表达式,所以重量级的比如词法分析,语法分析,抽象语法树🌲三件套就不太合适了。(当然也不是不行,只是有点大材小用,而个人能力又有限,对于ANTLR调优之类不太擅长)


说起数学公式解析,当然离不开老朋友逆波兰表达式,也就是后缀表达式,他能忽略括号等优先级问题,按照顺序一一计算。本次也打算从这里入手,慢慢再加入其他一些特性。


先总结下需求:



  • 支持加减乘除与括号,以及括号嵌套。

  • 支持负数/负表达式以及连续负号。比如 1*-2=-2, 1*--2=2, 1*-(2+3)=-5

  • 支持固定的函数,以及函数与表达式的相互嵌套。比如 1+abs(-2-3)=6

  • 支持常量,例如 pi, e


因为使用场景频率较高,所以解析过程中不要使用临时对象,如果非要使用要建立对象池避免 GC 压力过大。


基础实现


首先是最基本的,中缀转后缀表达式。再捋一下基本思想:


准备一个 OP 栈存放操作符。从头开始扫描字符串,遇到数字则直接输出(暂且称之为输出),否则假设 OP 栈顶元素为 A,扫描到的标识符为 B:



  1. 若 B 是右括号,则将栈中元素依次出栈输出,直到左括号。括号出栈不输出。

  2. 若 A 为空 或 A 是左括号 或 B 是左括号,则 B 入栈。

  3. 若 B 优先级大于 A,则 B 入栈。

  4. 否则 A 出栈输出并循环,直到满足上述条件之一。


扫描结束后将 OP 元素全部出栈输出,得到完整的后缀表达式。


按照上述算法,表达式 2*(3+4) 转换后输出为 234+*。然后只需要按顺序扫描输出,遇到数字入栈,遇到运算符出栈操作数,然后将计算结果再入栈,最后栈中唯一元素就是答案了。


不难看出这种方法相当于遍历了两遍。其实我们可以再准备一个表达式 exp 栈,在输出的过程中直接入 exp,如果遇到操作符,则进行计算再将结果入 exp。这样只需要遍历一遍就能得到答案。



💡 Tips


复盘 B 入栈的条件,可以发现栈中可能存在的元素包含运算符与左括号。右括号永远不会入栈。也就是说 A 可能的值为运算符与左括号。反直觉地,我们只需要将左括号(定义为优先级最低,即可将括号也作为运算符看待一并计入优先级比较,避免一小段特殊逻辑代码。

但请注意 AB 都是左括号时,虽然优先级相等,但是 B 应当入栈而不是 A 出栈。 因此相比于直接定义 int 优先级,我更偏向于定义一个二维 bool 数组,用于快捷查找任意两个符号比较,应当出栈还是入栈。



到此为止已经解决了四则运算与括号的问题。


额外需求


函数


我的基本思想就是将函数作为一个特殊的操作符(和加号一样)处理。那么就会产生几个问题:



  1. 函数的操作数都在操作符的后面。

  2. 函数的优先级如何定义。

  3. 参数的分隔符,怎么办。

  4. 函数什么时候可以出栈?


第一个问题其实不影响什么。我们思考一下常规减号-的处理流程。首先将左边操作数输出,然后将减号入栈,最后输出右边操作数。对比一下函数:首先将函数(特殊操作符)入栈,然后将参数依次输出(当作操作数)。显然,两者最终的输出以及栈是一样的,即:操作数从左至右依次输出,操作符入栈。因此操作数与操作符的相对位置并不重要。


问题二则更简单,显然函数的优先级应该是最高,遇到直接入栈就完事了,但是两个函数之间该如何比较?其实这种情况根本不可能发生,因为函数后必定紧跟着一个左括号(,一旦左括号入栈,则后续的操作符必定直接入栈。因此函数入栈时,栈顶不可能也是函数。


至于参数分隔符,我将其视为一个表达式的结束。因为每一个参数都可能是一个嵌套的表达式,我们知道函数在执行前必须先计算出所有参数的值。如此一来,参数分隔符,和右括号)一样不需要入栈,同时要弹出栈中的其他元素,直到遇左括号(但是不要把左括号出栈,因为左括号和函数是一体的,分隔符只是参数的结束,并不是函数的结束。


最后,既然函数的优先级最高,那么什么时候才能轮到它出栈呢?显而易见肯定不能等最后集中出栈,否则就成了薛定谔的参数了。之前讨论到函数的操作数都在右边,换句话说,当操作数全部输出时,就应该立即让函数出栈。答案呼之欲出:当函数结束的时候函数本身应该出栈,而右括号)就是函数的结束符。这个符号在基础章节已经被定义过了,遇到右括号,我们要循环出栈直到左括号。此时应该加上一条:左括号出栈后如果栈顶元素是函数,那么将其出栈并输出。 这就能保证在后缀表达式中函数可以紧挨着它的所有参数。


负号


负号可以视为一个单目运算符,为了区别于减号(-),这里用波浪线(~)指代负号。那么只需解决两个问题:



  1. 什么情况下减号需要视为负号?

  2. 负号优先级如何?


先来解决简单的,负号优先级应该是最高(除了函数之外)。因为负号总是和后面的数或表达式结合,不受前方运算符的影响。比如 1*~2=2


下面为了解决问题一,我罗列了整个表达式中所有可能的数据类型,然后一一判断此时减号应该如何解释。



























前方符号语义
左括号 (负号
其他运算符 +-x/负号
数字减号
右括号)额外判断

右括号等情况稍微复杂,正常来说前面是个表达式,那么后边应该为减号。但是我们的语法允许空括号 (),这种表达式经过解析后其实什么都没有。所以遇到右括号)得额外判断 exp 栈,如果栈不为空且栈顶是数字则为负号~,否则为减号-


这样我们就需要用一个变量来记录上一个符号的类型,以便判断语义时使用。连续负号情况不需要额外处理。


常量


常量可以说是最简单的额外需求了,简单到甚至不需要额外处理。读取到常量后直接视为数字处理就行了。


解析问题


最后来说一下解析问题。因为一个 Token 可能由多个字符组成,例如数字 12.3 有4个字符,函数 abs 有3个字符。所以本质上我们要手写一个定制的词法解析器,因为语法相对简单,所以难度不算太大。考虑到使用场景,这里的宗旨是整个字符串只扫描一遍,不回退不预读。 容错就不过多考虑了,最外层之间 try 一下。


首先是最简单的常量与函数解析。先来明确下他们的语法定义:以字母开头,只能包含字母数字与下划线_,大小写敏感。我们就可以提炼出下面的特征:(为了便于描述,这里把常量和函数名统称为标识符id)



  • 遇到的第一个字母一定是 id 的开头。

  • 之后遇到的第一个非字母数字下划线一定表示 id 结束。


那么算法就水到渠成了。为了提高 id 拼凑效率,我在外部定义了一个 StringBuilder 用来拼接。当然,还有其他方案,例如记录 id 首末 index 然后一次性提取等。




接下来是识别数字,包括小数。数字可以包含数字和小数点.。类似的,遇到的一个数字或小数点.表示一个数字的开始,之后遇到的第一个非数字且非小数点表示数字的结束。


可以用上面 id 的方法来记录数字字符串,最后一次性地调用 kotlin 标准库函数转换为 double 类型。不过这里扣个字眼:标准库转换的时候必然要扫描字符串,而我们已经扫描一遍了,所以做了重复工作。为此,我定义一个 double 变量 num=0,以及一个表示小数位数的 double fraction=1。扫描到数字后将 num *10 然后加上当前数字。若在小数点之后,则先把 fraction / 10,然后乘以当前数字最后加到 num 上。


如此一来,在扫描的同时我们就实现了字符串到数字类型的转换。


作者:晨鹤
链接:https://juejin.cn/post/6957336568046714917
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

收起阅读 »

Compose Preview 的 UX 设计之旅

本文由来自 Android Developer UX 团队的 Preethi Srinivas (UX 研究员) 和 Paris Hsu (交互设计师) 所撰写。 Jetpack Compose 刚刚进入 测试阶段 啦!🎉 在此激动人心的时刻,Android ...
继续阅读 »

本文由来自 Android Developer UX 团队的 Preethi Srinivas (UX 研究员) 和 Paris Hsu (交互设计师) 所撰写。


Jetpack Compose 刚刚进入 测试阶段 啦!🎉 在此激动人心的时刻,Android Developer UX 团队想邀请您进入我们的世界,走进我们设计 Compose Preview 的设计之旅,旅程将从理解我们面临的挑战、方向的形成,以及原型设计和评估开始。


背景: 理解挑战


Jetpack Compose 是新一代 Android 开发的 UI 工具包,它可更简单高效地构建出精美且性能卓越的 Android 应用。它使用了直观的 Kotlin API,能够做到 UI 随着应用状态的变化而自动更新。当我们的团队第一次听说这个项目时,我们无比期待 Compose 项目的无限可能,它具有将逻辑和数据混合绑定到 UI 的潜力,以及为开发者解锁新的能力。然而,这种新的构建 UI 方式也带来了新的设计挑战。


对于经典的 Android 视图,UI 是静态的,且主要是通过 XML 进行创建。这意味着对 XML 的更改几乎可以立即在 UI 中反映出来,我们可以根据这种特性来构建像 Layout Editor 这样的使用体验,让开发者们通过可视化的拖放操作来编辑他们应用的布局,相应的更改也会自动映射到对 XML 的更改。然而,使用 Compose 的每一次修改,都必须编译 Kotlin 代码才能反映出变化,这就意味着需要花费时间,从而减慢了迭代和创建的过程。


集思构想: 冲刺设计方案


为了探究如何在 Compose 中支持这种开发 UI 代码的新模式,我们团队和我们的软件工程师、开发者关系工程师和产品管理伙伴一起举办了一个研讨会,以解决一个设计挑战: 我们如何利用开发者对现有工具的使用经验来帮助他们创建和掌握 Compose UI?


我们基于 设计思维方法,从理解问题和调整问题的工作场景开始思考。这一过程需要团队在 "我们可以怎样... (How Might We…)" 这一框架下写出自己的想法,然后通过亲和图法 (affinitized) 去识别和提炼这些手头的设计问题。我们以之前的研究为出发点,将自己想象为开发者,结合实际开发过程会遇到的不同阶段,来引导小组进行思考,并绘制出解决方案的工具草图。





Compose 设计研讨会



这一设计研讨会帮助我们总结了几点核心原则,为 Compose Tooling 在 2020 年和之后的发展路线奠定了基础:



  • 基于以往为 XML 构建工具所积累的经验为基础

  • 围绕代码进行界面的绘制

  • 优化迭代和实验


这些原则构成了我们产品设计理念前进的基础。例如,Compose Preview 构建出的使用体验在外观和使用上都会让用户觉得很熟悉,在此之上还补充了 Compose 的范式,通过轻量且可重复利用的 Composable 来构建布局。设计研讨会还鼓励我们更多地以代码为中心构建出 REPL 的编程环境,使得开发者在预览代码时拥有更多的控制权和灵活性 — 这样在本质上就提供了一个支持迭代、实验和学习的交互式编程环境。我们还设想了提供超越 XML 之外的新体验,例如 Interactive Preview (互动预览),它可以支持在 IDE 内部被隔离的沙盒环境下的实时交互;Deploy Preview (部署预览),用于在不重新运行整个应用的前提下,将 Preview Composable 部署到模拟器或者真机上。


原型设计: 早期验证


为了验证我们的假设和设计路径,我们开始对研讨会中的想法进行原型设计,并在用户研究案例中对其进行测试。我们开设了一些研究,以便可以验证当前的方向是否正确,并获取关于未来想法和相关投入的反馈。我们选择了一种迭代方法来获取反馈,从而在涉及其他与 Compose 相关主题的多个研究中,将与 Preview 相关的主题进行了折叠。


例如,为了解 Compose Preview 的使用体验,我们首先列出开发者将会问出的问题:



  • 开发者该如何使用 Compose Preview?

  • 在什么情况下,开发者想要预览动态交互的效果?

  • 在真机或模拟器上部署隔离式 Composable 并与之交互的功能对开发者的帮助程度如何?


我们邀请了开发者来加入我们的 Coding Session,在一个以研究为目的而创建的 Compose 项目中完成一些简单的编程练习。这种方式节省了配置开发环境的时间和精力,尤其是 Compose 仍处于开发者预览版之前的阶段,这一方法还能够帮助我们关注开发者在使用 Preview 和其他 Compose API 时的体验。早期的研究确实需要围绕产品稳定性的问题进行展开,因为 Preview 并非总能按照预期正常工作。研究计划预见到了这些不可避免的问题,同时也能够提供非常早期的洞察。




通过 Coding Session 进行可用性研究



从这些 Session 中我们发现,一些开发者会在区分 Preview 工具栏上的 "Refresh" 图标和横幅中的 "Refresh & Build" 图标时感到困惑。大多数开发者不会意识到 "Refresh" 只更新代码而不需要完整构建,而 "Refresh & Build" 则会通过构建更新全部修改。



"如果 Refresh 和 Refresh & Build 希望保持一致,那么将它们放在一起会更好 — 我最初以为 Refresh 按钮只会刷新 UI 而不会构建项目。"



预览 Refresh & Build (之前和之后)



预览 Refresh & Build (之前和之后)



得到该反馈之后,我们决定将两者统一起来,并改进了体验,当用户点击图标或者横幅时,Preview 会根据代码变化的情况来确定是需要进行刷新还是重新构建。


从早期几轮开发者参与的研究中,产生了一个对于 Compose Preview 的深刻体会是,开发者在 Compose 中进行 UI 原型设计时,会感受到一种掌控感,以及工作效率的提升。



"Refresh 模式让我可以快速完成 UI 的原型设计。加上可以使用功能强大的 Kotlin 创建 UI,以及利用 @Preview 函数展示实例数据,比起老式的 XML 中提供的命名空间助手要好得多。"



我们还感受到了开发者在发现 Preview 中同 Composable 交互时能够导航到对应的代码这一功能时,他们所感到的惊讶和喜悦。



"我才发现这个功能,非常开心,我可以在 Preview 中点击不同的视图,直接跳转到绘制该视图的代码里。我很期待在 Jetpack Compose 中看到更多类似的功能。"



在可用性研究中,我们观察到开发者们会通过在 Preview 中点击不同的 UI 元素来跳转到项目的不同地方 — 这需要人们对 Preview 中的 UI 层次结构有着较为深刻的理解。一些开发者发现,当在 Compose Preview 和代码导航之间进行交互时,会有错位的问题出现。例如,在 Column 中的 Text Composable 区域之外点击,会跳转到代码编辑器中定义 Column 的那一行中去。因而我们通过提供 Composable outline 来增强 Preview 的使用体验,以便在布局中围绕 Composable 提供功能可见性。


Preview 代码跳转功能



Preview 代码跳转功能



沉浸式: 以日记形式进行记录


相对而言,在现场亲自参与可用性研究更容易创造价值,并激发出新的想法。然而由于时间的限制,很难深入地去对主题进行挖掘。因此,我们调整了研究方法,开始更多使用一种远程技术,让开发者自己对某个 Compose 项目进行几周的使用。这段时间内,开发者需要写日记,记录他们在指定项目或者自己项目中关于工作流程上的一些问题。通常我们还会在几周的探索之后,再搭配一次访谈,目的是为了更好了解开发者日记中的具体内容。在几天的探索之后,我们还邀请了一些开发者通过 Google Meet 的 Coding Session,来观察并确定哪些部分的工作是进展顺利的,以及一些可以被改进的地方。


通过提问式的日记来帮助反馈的获取



通过提问式的日记来帮助反馈的获取



在这些研究中出现了一点共性 — 开发者会使用 Preview 来创建工作流程,还会利用它进行一些故障排除/验证的工作。例如,在创建 UI 时,开发者会更倾向于使用 Refresh 模式,而在使用手势/交互时,他们会切换到 Interactive 模式,至于 Deploy 模式,则最常用于故障排除和验证检查。



"当我发现在 Interactive 模式下长按可以显示星星的动画时,我非常的开心。但是,之后的长按操作就不管用了 — 动画再也不出现了。通过在模拟器上部署 Preview 模式,我能确认动画是可以正常工作的。如果 Interactive 模式能够更加稳定的话,它将会成为我测试交互性功能和动画的首选模式。有趣的是,在创建新的 UI 并查看它们的渲染方式时,我大部分时间都不需要使用它。"



此外,我们从一些开发者那里得到反馈,在考虑整个布局之前,能够提取并集中实现一个单独的 Composable 的重要性。



"只部署 Preview 意味着我不需要为了测试一个新的组件,而把 UI 关联到实际的流程中 (包含多个界面和用户输入)。这样使得调试 + 改变复杂 UI 变得更加容易。"



将想法付诸于行动


我们在研究的基础之上确立了要前进的方向,这有助于将开发人员对我们工具的见解和遇到的问题反馈到我们的产品迭代中 — 同时能确保我们也能够捕获到新兴的主题来塑造我们的设计理念。以下是几个示例:


Preview 新用户的使用体验


我们发现开发者在探索如何开始创建 Preview 时会有困难 — 很多人在示例项目中留意到了 Preview,但是在自己的项目中就不能够复刻出类似的使用体验。不直观的设计往往导致在创建 Preview Composable 时,对 Compose 编译器到底支持什么功能而产生误解。例如,我们观察到一些开发者试图预览一个接受参数的 Composable,而这一功能 Compose 是不支持的。在这种情况下,编译器提供的错误信息往往会被忽略或遗漏。



"我无法在 Preview 中显示 Split 视图,即使我是直接从一个示例项目中复制过来的代码,它也无法让 Preview 注解正常工作。"



这一重要的发现使我们引入了默认状态,如果 Kotlin 文件尚未定义 Preview Composable,那么拆分编辑器 (这一概念源于 View/XML 世界中的 Preview) 则始终处于可见状态。我们相信该解决方案不仅可以提高对 Preview 的认知和发现能力,还可以提供创建和操作 Preview 相关的学习经验。


Preview 默认状态



Preview 默认状态



增强编码体验


在调查研究中,开发者问了我们这样几个问题:



  • 如何在浅色和深色主题背景中预览一个布局?

  • 如何利用样本数据预览一个布局?

  • 我如何利用 Preview 来确定我的代码中在哪定义了某个特定的 UI 元素?

  • 有没有一种方法可以让 Compose 模仿 View/XML 世界中的 Preview 使用体验,特别是在 Preview 中如何快速查看因为代码变化产生的视觉变化?


这些问题都指向了一点 — 开发者正在寻找一种快速简单的机制来操作 Preview,并期望它能更快地进行迭代。


我们将继续对开发者反馈的新功能进行原型设计和测试,例如 Preview Configuration Picker (Preview 配置选择器),它允许开发者可视化地配置他们的布局 (例如在不同的主题、设备、语言等),以提高 @Preview API 的可发现性和可学习性。


Preview 配置选择器



Preview 配置选择器



另一个例子是 Live literals (实时显示字面量类型),这是来自工程团队的解决方案,通过在 Preview 面板中对一些 Composable 值 (例如 Boolean、Char、String、Color 等) 引入实时更新,来优化迭代开发的速度。


Live Literal 的实际体验



Live Literal 的实际体验



PreviewParameterProvider 是我们将样本数据纳入 Preview 中来允许真实上下文测试的又一例子。


使用 PreviewParameterProvider



使用 PreviewParameterProvider



旅程仍未结束


我们希望这篇文章能让您了解我们是如何根据您的反馈来改进 Compose Preview 的。当然,我们的旅程并没有就此结束!我们还有很多继续改善 Compose Preview 及其工具使用体验的计划。例如,将 Live Literals 功能扩展到字面量类型之外,以继续优化迭代开发的速度。


如果您在使用 Compose 工具时遇到问题,或者是有任何可以改善使用体验的新功能的想法,请 告诉我们。我们也在寻找开发者参与到用户研究 Session 中,您可以 注册 参与。

作者:Android_开发者
链接:https://juejin.cn/post/6959416526562656292
来源:掘金
著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。

收起阅读 »

iOS 开发:『Crash 防护系统』(二)KVO 防护

1. KVO Crash 的常见原因KVO(Key Value Observing) 翻译过来就是键值对观察,是 iOS 观察者模式的一种实现。KVO 允许一个对象监听另一个对象特定属性的改变,并在改变时接收到事件。但是 KVO API 的设计,我个人觉得不是...
继续阅读 »

1. KVO Crash 的常见原因

KVO(Key Value Observing) 翻译过来就是键值对观察,是 iOS 观察者模式的一种实现。KVO 允许一个对象监听另一个对象特定属性的改变,并在改变时接收到事件。但是 KVO API 的设计,我个人觉得不是很合理。被观察者需要做的工作太多,日常使用时稍不注意就会导致崩溃。

KVO 日常使用造成崩溃的原因通常有以下几个:

1. KVO 添加次数和移除次数不匹配:

  • 移除了未注册的观察者,导致崩溃。

  • 重复移除多次,移除次数多于添加次数,导致崩溃。

  • 重复添加多次,虽然不会崩溃,但是发生改变时,也同时会被观察多次。

2. 被观察者提前被释放,被观察者在 dealloc 时仍然注册着 KVO,导致崩溃。 例如:被观察者是局部变量的情况(iOS 10 及之前会崩溃)。

3. 添加了观察者,但未实现 observeValueForKeyPath:ofObject:change:context: 方法,导致崩溃。

4. 添加或者移除时 keypath == nil,导致崩溃。

2. KVO 防止 Crash 常见方案

为了避免上面提到的使用 KVO 造成崩溃的问题,于是出现了很多关于 KVO 的第三方库,比如最出名的就是 FaceBook 开源的第三方库 facebook / KVOController。

FBKVOController 对 KVO 机制进行了额外的一层封装,框架不但可以自动帮我们移除观察者,还提供了 block 或者 selector 的方式供我们进行观察处理。不可否认的是,FBKVOController 为我们的开发提供了很大的便利性。但是相对而言,这种方式对项目代码的侵入性比较大,必须依靠编码规范来强制约束团队人员使用这种方式。

那么有没有一种对项目代码侵入性小,同时还能有效防护 KVO 崩溃的防护机制呢?

网上有很多类似的方案可以参考一下。

方案一:大白健康系统 -- iOS APP运行时 Crash 自动修复系统

1. 首先为 NSObject 建立一个分类,利用 Method Swizzling,实现自定义的 BMP_addObserver:forKeyPath:options:context:、BMP_removeObserver:forKeyPath:、BMP_removeObserver:forKeyPath:context:、BMPKVO_dealloc 方法,用来替换系统原生的添加移除观察者方法的实现。

2. 然后在观察者和被观察者之间建立一个 KVODelegate 对象,两者之间通过 KVODelegate 对象 建立联系。然后在添加和移除操作时,将 KVO 的相关信息例如 observer、keyPath、options、context 保存为 KVOInfo 对象,并添加到 KVODelegate 对象 中对应 的 关系哈希表 中,对应原有的添加观察者。关系哈希表的数据结构:{keypath : [KVOInfo 对象1, KVOInfo 对象2, ... ]}

3. 在添加和移除操作的时候,利用 KVODelegate 对象 做转发,把真正的观察者变为 KVODelegate 对象,而当被观察者的特定属性发生了改变,再由 KVODelegate 对象 分发到原有的观察者上。

那么,BayMax 系统是如何避免 KVO 崩溃的呢?

1. 添加观察者时:通过关系哈希表判断是否重复添加,只添加一次。

2. 移除观察者时:通过关系哈希表是否已经进行过移除操作,避免多次移除。

3. 观察键值改变时:同样通过关系哈希表判断,将改变操作分发到原有的观察者上。

另外,为了避免被观察者提前被释放,被观察者在 dealloc 时仍然注册着 KVO 导致崩溃。BayMax 系统还利用 Method Swizzling 实现了自定义的 dealloc,在系统 dealloc 调用之前,将多余的观察者移除掉。

方案二: ValiantCat / XXShield(第三方框架)

XXShield 实现方案和 BayMax 系统类似。也是利用一个 Proxy 对象用来做转发, 真正的观察者是 Proxy,被观察者出现了通知信息,由 Proxy 做分发。不过不同点是 Proxy 里面保存的内容没有前者多。只保存了 _observed(被观察者) 和关系哈希表,这个关系哈希表中只维护了 keyPath 和 observer 的关系。

关系哈希表的数据结构:{keypath : [observer1, observer2 , ...](NSHashTable)} 。

XXShield 在 dealloc 中也做了类似将多余观察者移除掉的操作,是通过关系数据结构和 _observed ,然后调用原生移除观察者操作实现的。

方案三: JackLee18 / JKCrashProtect(第三方框架)

JKCrashProtect 相对于前两个方案来讲,看上去更加的简洁明了。他的不同点在于没有使用 delegate。而是直接在分类中建立了一个关系哈希表,用来保存 {keypath : [observer1, observer2 , ...](NSHashTable)} 的关系。

添加的时候,如果关系哈希表中与 keyPath 对应的已经有了相关的观察者,就不再进行添加。同样移除观察者的时候,也在哈希表中进行查找,如果存在 observer、keyPath 的信息,就移除掉,否则就不进行移除操作。

不过,这个框架并没有对被观察者在 dealloc 时仍然注册着 KVO ,造成崩溃的情况进行处理。

3. 我的 KVO 防护实现

参考了这几个方法的实现后,分别实现了一下之后,最终还是选择了 方案一、方案二 这两种方案的实现思路。

1. 我使用了 YSCKVOProxy 对象,在 YSCKVOProxy 对象 中使用 {keypath : [observer1, observer2 , ...](NSHashTable)} 结构的 关系哈希表 进行 observer、keyPath 之间的维护。

2. 然后利用 YSCKVOProxy 对象 对添加、移除、观察方法进行分发处理。

3. 在分类中自定义了 dealloc 的实现,移除了多余的观察者。

  • 代码如下所示:

#import "NSObject+KVODefender.h"
#import "NSObject+MethodSwizzling.h"
#import <objc/runtime.h>

// 判断是否是系统类
static inline BOOL IsSystemClass(Class cls){
BOOL isSystem = NO;
NSString *className = NSStringFromClass(cls);
if ([className hasPrefix:@"NS"] || [className hasPrefix:@"__NS"] || [className hasPrefix:@"OS_xpc"]) {
isSystem = YES;
return isSystem;
}
NSBundle *mainBundle = [NSBundle bundleForClass:cls];
if (mainBundle == [NSBundle mainBundle]) {
isSystem = NO;
}else{
isSystem = YES;
}
return isSystem;
}


#pragma mark - YSCKVOProxy 相关

@interface YSCKVOProxy : NSObject

// 获取所有被观察的 keyPaths
- (NSArray *)getAllKeyPaths;

@end

@implementation YSCKVOProxy
{
// 关系数据表结构:{keypath : [observer1, observer2 , ...](NSHashTable)}
@private
NSMutableDictionary<NSString *, NSHashTable<NSObject *> *> *_kvoInfoMap;
}

- (instancetype)init {
self = [super init];
if (self) {
_kvoInfoMap = [NSMutableDictionary dictionary];
}
return self;
}

// 添加 KVO 信息操作, 添加成功返回 YES
- (BOOL)addInfoToMapWithObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
options:(NSKeyValueObservingOptions)options
context:(void *)context {

@synchronized (self) {
if (!observer || !keyPath ||
([keyPath isKindOfClass:[NSString class]] && keyPath.length <= 0)) {
return NO;
}

NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];
if (info.count == 0) {
info = [[NSHashTable alloc] initWithOptions:(NSPointerFunctionsWeakMemory) capacity:0];
[info addObject:observer];

_kvoInfoMap[keyPath] = info;

return YES;
}

if (![info containsObject:observer]) {
[info addObject:observer];
}

return NO;
}
}

// 移除 KVO 信息操作, 添加成功返回 YES
- (BOOL)removeInfoInMapWithObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath {

@synchronized (self) {
if (!observer || !keyPath ||
([keyPath isKindOfClass:[NSString class]] && keyPath.length <= 0)) {
return NO;
}

NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];

if (info.count == 0) {
return NO;
}

[info removeObject:observer];

if (info.count == 0) {
[_kvoInfoMap removeObjectForKey:keyPath];

return YES;
}

return NO;
}
}

// 添加 KVO 信息操作, 添加成功返回 YES
- (BOOL)removeInfoInMapWithObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
context:(void *)context {
@synchronized (self) {
if (!observer || !keyPath ||
([keyPath isKindOfClass:[NSString class]] && keyPath.length <= 0)) {
return NO;
}

NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];

if (info.count == 0) {
return NO;
}

[info removeObject:observer];

if (info.count == 0) {
[_kvoInfoMap removeObjectForKey:keyPath];

return YES;
}

return NO;
}
}

// 实际观察者 yscKVOProxy 进行监听,并分发
- (void)observeValueForKeyPath:(NSString *)keyPath
ofObject:(id)object
change:(NSDictionary<NSKeyValueChangeKey,id> *)change
context:(void *)context {

NSHashTable<NSObject *> *info = _kvoInfoMap[keyPath];

for (NSObject *observer in info) {
@try {
[observer observeValueForKeyPath:keyPath ofObject:object change:change context:context];
} @catch (NSException *exception) {
NSString *reason = [NSString stringWithFormat:@"KVO Warning : %@",[exception description]];
NSLog(@"%@",reason);
}
}
}

// 获取所有被观察的 keyPaths
- (NSArray *)getAllKeyPaths {
NSArray <NSString *>*keyPaths = _kvoInfoMap.allKeys;
return keyPaths;
}

@end


#pragma mark - NSObject+KVODefender 分类

@implementation NSObject (KVODefender)

+ (void)load {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{

// 拦截 `addObserver:forKeyPath:options:context:` 方法,替换自定义实现
[NSObject yscDefenderSwizzlingInstanceMethod: @selector(addObserver:forKeyPath:options:context:)
withMethod: @selector(ysc_addObserver:forKeyPath:options:context:)
withClass: [NSObject class]];

// 拦截 `removeObserver:forKeyPath:` 方法,替换自定义实现
[NSObject yscDefenderSwizzlingInstanceMethod: @selector(removeObserver:forKeyPath:)
withMethod: @selector(ysc_removeObserver:forKeyPath:)
withClass: [NSObject class]];

// 拦截 `removeObserver:forKeyPath:context:` 方法,替换自定义实现
[NSObject yscDefenderSwizzlingInstanceMethod: @selector(removeObserver:forKeyPath:context:)
withMethod: @selector(ysc_removeObserver:forKeyPath:context:)
withClass: [NSObject class]];

// 拦截 `dealloc` 方法,替换自定义实现
[NSObject yscDefenderSwizzlingInstanceMethod: NSSelectorFromString(@"dealloc")
withMethod: @selector(ysc_kvodealloc)
withClass: [NSObject class]];
});
}

static void *YSCKVOProxyKey = &YSCKVOProxyKey;
static NSString *const KVODefenderValue = @"YSC_KVODefender";
static void *KVODefenderKey = &KVODefenderKey;

// YSCKVOProxy setter 方法
- (void)setYscKVOProxy:(YSCKVOProxy *)yscKVOProxy {
objc_setAssociatedObject(self, YSCKVOProxyKey, yscKVOProxy, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}

// YSCKVOProxy getter 方法
- (YSCKVOProxy *)yscKVOProxy {
id yscKVOProxy = objc_getAssociatedObject(self, YSCKVOProxyKey);
if (yscKVOProxy == nil) {
yscKVOProxy = [[YSCKVOProxy alloc] init];
self.yscKVOProxy = yscKVOProxy;
}
return yscKVOProxy;
}

// 自定义 addObserver:forKeyPath:options:context: 实现方法
- (void)ysc_addObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
options:(NSKeyValueObservingOptions)options
context:(void *)context {

if (!IsSystemClass(self.class)) {
objc_setAssociatedObject(self, KVODefenderKey, KVODefenderValue, OBJC_ASSOCIATION_RETAIN);
if ([self.yscKVOProxy addInfoToMapWithObserver:observer forKeyPath:keyPath options:options context:context]) {
// 如果添加 KVO 信息操作成功,则调用系统添加方法
[self ysc_addObserver:self.yscKVOProxy forKeyPath:keyPath options:options context:context];
} else {
// 添加 KVO 信息操作失败:重复添加
NSString *className = (NSStringFromClass(self.class) == nil) ? @"" : NSStringFromClass(self.class);
NSString *reason = [NSString stringWithFormat:@"KVO Warning : Repeated additions to the observer:%@ for the key path:'%@' from %@",
observer, keyPath, className];
NSLog(@"%@",reason);
}
} else {
[self ysc_addObserver:observer forKeyPath:keyPath options:options context:context];
}
}

// 自定义 removeObserver:forKeyPath:context: 实现方法
- (void)ysc_removeObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath
context:(void *)context {

if (!IsSystemClass(self.class)) {
if ([self.yscKVOProxy removeInfoInMapWithObserver:observer forKeyPath:keyPath context:context]) {
// 如果移除 KVO 信息操作成功,则调用系统移除方法
[self ysc_removeObserver:self.yscKVOProxy forKeyPath:keyPath context:context];
} else {
// 移除 KVO 信息操作失败:移除了未注册的观察者
NSString *className = NSStringFromClass(self.class) == nil ? @"" : NSStringFromClass(self.class);
NSString *reason = [NSString stringWithFormat:@"KVO Warning : Cannot remove an observer %@ for the key path '%@' from %@ , because it is not registered as an observer", observer, keyPath, className];
NSLog(@"%@",reason);
}
} else {
[self ysc_removeObserver:observer forKeyPath:keyPath context:context];
}
}

// 自定义 removeObserver:forKeyPath: 实现方法
- (void)ysc_removeObserver:(NSObject *)observer
forKeyPath:(NSString *)keyPath {

if (!IsSystemClass(self.class)) {
if ([self.yscKVOProxy removeInfoInMapWithObserver:observer forKeyPath:keyPath]) {
// 如果移除 KVO 信息操作成功,则调用系统移除方法
[self ysc_removeObserver:self.yscKVOProxy forKeyPath:keyPath];
} else {
// 移除 KVO 信息操作失败:移除了未注册的观察者
NSString *className = NSStringFromClass(self.class) == nil ? @"" : NSStringFromClass(self.class);
NSString *reason = [NSString stringWithFormat:@"KVO Warning : Cannot remove an observer %@ for the key path '%@' from %@ , because it is not registered as an observer", observer, keyPath, className];
NSLog(@"%@",reason);
}
} else {
[self ysc_removeObserver:observer forKeyPath:keyPath];
}

}

// 自定义 dealloc 实现方法
- (void)ysc_kvodealloc {
@autoreleasepool {
if (!IsSystemClass(self.class)) {
NSString *value = (NSString *)objc_getAssociatedObject(self, KVODefenderKey);
if ([value isEqualToString:KVODefenderValue]) {
NSArray *keyPaths = [self.yscKVOProxy getAllKeyPaths];
// 被观察者在 dealloc 时仍然注册着 KVO
if (keyPaths.count > 0) {
NSString *reason = [NSString stringWithFormat:@"KVO Warning : An instance %@ was deallocated while key value observers were still registered with it. The Keypaths is:'%@'", self, [keyPaths componentsJoinedByString:@","]];
NSLog(@"%@",reason);
}

// 移除多余的观察者
for (NSString *keyPath in keyPaths) {
[self ysc_removeObserver:self.yscKVOProxy forKeyPath:keyPath];
}
}
}
}


[self ysc_kvodealloc];
}

@end

4. 测试 KVO 防护效果

这里提供一下相关崩溃的测试代码:

/********************* KVOCrashObject.h 文件 *********************/
#import <Foundation/Foundation.h>

@interface KVOCrashObject : NSObject

@property (nonatomic, copy) NSString *name;

@end

/********************* KVOCrashObject.m 文件 *********************/
#import "KVOCrashObject.h"

@implementation KVOCrashObject

@end

/********************* ViewController.m 文件 *********************/
#import "ViewController.h"
#import "KVOCrashObject.h"

@interface ViewController ()

@property (nonatomic, strong) KVOCrashObject *objc;

@end

@implementation ViewController

- (void)viewDidLoad {
[super viewDidLoad];
// Do any additional setup after loading the view.

self.objc = [[KVOCrashObject alloc] init];
}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {

// 1.1 移除了未注册的观察者,导致崩溃
[self testKVOCrash11];

// 1.2 重复移除多次,移除次数多于添加次数,导致崩溃
// [self testKVOCrash12];

// 1.3 重复添加多次,虽然不会崩溃,但是发生改变时,也同时会被观察多次。
// [self testKVOCrash13];

// 2. 被观察者 dealloc 时仍然注册着 KVO,导致崩溃
// [self testKVOCrash2];

// 3. 观察者没有实现 -observeValueForKeyPath:ofObject:change:context:导致崩溃
// [self testKVOCrash3];

// 4. 添加或者移除时 keypath == nil,导致崩溃。
// [self testKVOCrash4];
}

/**
1.1 移除了未注册的观察者,导致崩溃
*/
- (void)testKVOCrash11 {
// 崩溃日志:Cannot remove an observer XXX for the key path "xxx" from XXX because it is not registered as an observer.
[self.objc removeObserver:self forKeyPath:@"name"];
}

/**
1.2 重复移除多次,移除次数多于添加次数,导致崩溃
*/
- (void)testKVOCrash12 {
// 崩溃日志:Cannot remove an observer XXX for the key path "xxx" from XXX because it is not registered as an observer.
[self.objc addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
self.objc.name = @"0";
[self.objc removeObserver:self forKeyPath:@"name"];
[self.objc removeObserver:self forKeyPath:@"name"];
}

/**
1.3 重复添加多次,虽然不会崩溃,但是发生改变时,也同时会被观察多次。
*/
- (void)testKVOCrash13 {
[self.objc addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
[self.objc addObserver:self forKeyPath:@"name" options:NSKeyValueObservingOptionNew context:NULL];
self.objc.name = @"0";
}

/**
2. 被观察者 dealloc 时仍然注册着 KVO,导致崩溃
*/
- (void)testKVOCrash2 {
// 崩溃日志:An instance xxx of class xxx was deallocated while key value observers were still registered with it.
// iOS 10 及以下会导致崩溃,iOS 11 之后就不会崩溃了
KVOCrashObject *obj = [[KVOCrashObject alloc] init];
[obj addObserver: self
forKeyPath: @"name"
options: NSKeyValueObservingOptionNew
context: nil];
}

/**
3. 观察者没有实现 -observeValueForKeyPath:ofObject:change:context:导致崩溃
*/
- (void)testKVOCrash3 {
// 崩溃日志:An -observeValueForKeyPath:ofObject:change:context: message was received but not handled.
KVOCrashObject *obj = [[KVOCrashObject alloc] init];

[self addObserver: obj
forKeyPath: @"title"
options: NSKeyValueObservingOptionNew
context: nil];

self.title = @"111";
}

/**
4. 添加或者移除时 keypath == nil,导致崩溃。
*/
- (void)testKVOCrash4 {
// 崩溃日志: -[__NSCFConstantString characterAtIndex:]: Range or index out of bounds
KVOCrashObject *obj = [[KVOCrashObject alloc] init];

[self addObserver: obj
forKeyPath: @""
options: NSKeyValueObservingOptionNew
context: nil];

// [self removeObserver:obj forKeyPath:@""];
}


- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary*)change context:(void *)context {

NSLog(@"object = %@, keyPath = %@", object, keyPath);
}

@end

可以将示例项目 NSObject+KVODefender.m 中的 + (void)load; 方法注释掉或打开进行防护前后的测试。

经测试可以发现,成功的拦截了这几种因为 KVO 使用不当导致的崩溃。

链接:https://www.jianshu.com/p/e3713d309283

收起阅读 »

Swift高级分享 - 在Swift中构建模型数据

在代码库中建立可靠的结构通常是必不可少的,以便更容易使用。然而,实现一个既足够严格以防止错误和问题的结构 - 以及对现有功能足够灵活的结构以及我们想要的任何未来变化 - 都可能非常棘手。对于模型代码而言尤其如此,模型代码通常由许多不同的功能使用,每个功能都有自...
继续阅读 »

在代码库中建立可靠的结构通常是必不可少的,以便更容易使用。然而,实现一个既足够严格以防止错误和问题的结构 - 以及对现有功能足够灵活的结构以及我们想要的任何未来变化 - 都可能非常棘手。

对于模型代码而言尤其如此,模型代码通常由许多不同的功能使用,每个功能都有自己的一组要求。本周,让我们来看看构建核心模型的数据的几种不同技术,以及如何改进该结构对我们的其余代码库产生重大积极影响。

形成层次结构

在项目开始时,模型通常可以保持非常简单。由于我们尚未实现许多功能,因此我们的模型很可能不需要包含太多数据。然而,随着我们的代码库的增长,我们的模型经常发生变化 - 并且很容易达到一个简单的模型最终成为各种相关数据的“全能”的程度。

例如,假设我们正在构建一个电子邮件客户端,它使用Message模型来跟踪每条消息。最初,该模型可能只包含给定消息的主题行和正文,但此后逐渐增长为包含各种其他数据:

struct Message {
var subject: String
var body: String
let date: Date
var tags: [Tag]
var replySent: Bool
let senderName: String
let senderImage: UIImage?
let senderAddress: String
}

虽然为了呈现消息需要所有上述数据,但是直接将其保留在Message类型本身中会使事情变得有点混乱 - 并且很可能使消息更难以使用,尤其是当我们创建新实例时 - 撰写新邮件时或编写单元测试时。

缓解上述问题的一种方法是将数据分解为多个专用类型 - 然后我们可以使用它们来形成模型层次结构。例如,我们可能会将有关消息发送者的所有数据提取到Person结构中,并将所有元数据(例如消息的标记和日期)提取到Metadata类型中,如下所示:

struct Person {
var name: String
var image: UIImage?
var address: String
}

extension Message {
struct Metadata {
let date: Date
var tags: [Tag]
var replySent: Bool
}
}

现在,有了上述内容,我们可以为我们的Message类型提供一个更清晰的结构 - 因为每个数据不直接作为消息本身的一部分现在包含在更具上下文的专用类型中:

struct Message {
var subject: String
var body: String
var metadata: Metadata
let sender: Person
}

上述方法的另一个好处是,我们现在可以更容易地在不同的上下文中重用部分数据。例如,我们可以使用我们的新Person类型来实现联系人列表等功能,或者允许用户定义组 - 因为该数据不再直接绑定到该Message类型。

减少重复

除了用于更好地组织我们的代码之外,可靠的结构还可以帮助减少项目中的重复。假设我们的电子邮件应用程序使用事件驱动的方法来处理不同的用户操作 - 使用如下所示的Event枚举:

enum Event {
case add(Message)
case update(Message)
case delete(Message)
case move(Message, to: Folder)
}

使用枚举来定义各种代码需要处理的有限事件列表,这是在应用程序中建立更清晰数据流的好方法 - 但是我们当前的实现要求每个案例都包含Message事件所针对的事件 - 领先在Event类型本身内复制,以及在我们想要从事件的消息中提取信息时。

由于每个事件的操作都是对消息执行的,所以让我们将两者分开,并创建一个更简单的枚举类型,它将包含我们的所有操作:

enum Action {
case add
case update
case delete
case move(to: Folder)
}

然后,让我们再次形成一个层次结构 - 这一次通过重构我们的Event类型成为一个包含a Action和Message它将被应用于的包装器- 如下所示:

struct Event {
let message: Message
let action: Action
}

上述方法为我们提供了两全其美 - 处理事件现在只需要切换事件Action,现在可以使用message属性直接从事件的消息中提取数据。

递归结构

到目前为止,我们已经形成了层次结构,其中每个孩子和父母都是完全独立的类型 - 但这并不总是最优雅,或最方便的解决方案。假设我们正在开发一个显示各种内容的应用程序,例如文本和图像,并且我们再次使用枚举来定义每个内容 - 如下所示:

enum Content {
case text(String)
case image(UIImage)
case video(Video)
}

现在让我们说我们希望让用户能够形成一组内容 - 例如,通过创建收藏列表,或使用文件夹来组织内容。最初的想法可能是寻找一个专用Group类型,它包含组的名称和属于它的内容:

struct Group {
var name: String
var content: [Content]
}

然而,尽管上述内容看起来优雅且结构合理,但在这种情况下它有一些缺点。通过引入一种新的专用类型,我们将需要单独处理各个内容组 - 使得构建列表之类的内容变得更加困难 - 而且我们也无法轻松支持嵌套组。

因为在这种情况下,一个组只不过是构造内容的另一种方式,所以让它改为Content枚举本身的第一类成员,只需为它添加一个新的例子 - 就像这样:

enum Content {
case text(String)
case image(UIImage)
case video(Video)
case group(name: String, content: [Content])
}

我们上面基本上做的是创建Content一个递归数据结构。这种方法的优点在于我们现在可以重用我们用于处理内容的大部分相同代码来处理组,并且我们可以自动支持任意数量的嵌套组。

例如,以下是我们如何处理显示内容列表的表视图的单元格选择:

extension ListViewController: UITableViewDelegate {
func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
let content = contentList[indexPath.row]

switch content {
case .text(let string):
navigator.showText(string)
case .image(let image):
navigator.showImage(image)
case .video(let video):
navigator.openPlayer(for: video)
case .group(let name, let content):
navigator.openList(withTitle: name, content: content)
}
}
}

上面我们使用导航器模式导航到新目的地。您可以在“Swift中的导航”中找到更多相关信息。

由于Content现在是递归的,因此navigator.openList在处理组时调用现在只需创建一个ListViewController包含该组内容列表的新实例,使用户能够轻松地创建和导航任何内容层次结构,而我们只需要很少的努力。

专业模特

虽然能够重用代码通常是件好事,但有时最好创建一个更专业的新版本的模型,而不是尝试在非常不同的上下文中重用它。

回到之前的电子邮件应用程序示例,假设我们希望用户能够保存部分撰写的邮件草稿。而不是让该功能处理完整的Message实例,这需要不能用于草稿的数据 - 例如发件人的姓名或收到邮件的日期 - 让我们创建一个更简单的Draft类型,我们将嵌套在Message其他上下文中:

extension Message {
struct Draft {
var subject: String?
var body: String?
var recipients: [Person]
}
}

这样,我们可以自由地将某些属性作为选项,并减少加载和保存草稿时我们需要处理的数据量 - 而不会影响我们处理正确消息的任何代码。

结论

虽然哪种模型结构最适合每种情况,但在很大程度上取决于所需的数据类型以及数据的使用方式 - 在能够重用代码和不创建模型之间取得平衡太复杂,往往是关键。

形成清晰的层次结构 - 无论是使用专用类型还是通过创建递归数据结构 - 同时仍然偶尔为特定用例创建模型的专用版本,可以在我们的模型代码中形成更清晰的结构 - 并且像往常一样,常量重构和小改进通常是达到目的的方式。

链接:https://www.jianshu.com/p/06e7d171dd99

收起阅读 »

iOS开发性能监控

App 的性能问题虽然不会导致 App不可用,但依然会影响到用户体验。如果这个性能问题不断累积,达到临界点以后,问题就会爆发出来。这时,影响到的就不仅仅是用户了,还有负责App开发的你。线下性能监控其中线下监控使用的还是Instruments,Instrume...
继续阅读 »

App 的性能问题虽然不会导致 App不可用,但依然会影响到用户体验。如果这个性能问题不断累积,达到临界点以后,问题就会爆发出来。这时,影响到的就不仅仅是用户了,还有负责App开发的你。

线下性能监控

其中线下监控使用的还是Instruments,Instruments功能很强大,下图是Instruments的各种性能检测工具。


最新版本的Instruments 10还有以下两大优势:

1.Instruments基于os_signpost 架构,可以支持所有平台。

2.Instruments由于标准界面(Standard UI)和分析核心(Analysis Core)技术,使得我们可以非常方便地进行自定义性能监测工具的开发。当你想要给Instruments内置的工具换个交互界面,或者新创建一个工具的时候,都可以通过自定义工具这个功能来实现。

从整体架构来看,Instruments 包括Standard UI 和 Analysis Core 两个组件,它的所有工具都是基于这两个组件开发的。而且,你如果要开发自定义的性能分析工具的话,完全基于这两个组件就可以实现。

开发一款自定义Instruments工具,主要包括以下这几个步骤:

1.在Xcode中,点击File > New > Project;

2.在弹出的Project模板选择界面,将其设置为macOS;

3.选择 Instruments Package,点击后即可开始自定义工具的开发了。如下图所示。


经过上面的三步之后,会在新创建的工程里面生成一个.instrpkg 文件,接下来的开发过程主要就是对这个文件的配置工作了。这些配置工作中最主要的是要完成Standard UI 和 Analysis Core 的配置。

上面这些内容,就是你在开发一个自定义Instruments工具时,需要完成的编码工作了。可以看到,Instruments 10版本的自定义工具开发还是比较简单的。与此同时,苹果公司还提供了大量的代码片段,帮助你进行个性化的配置。你可以点击这个链接,查看官方指南中的详细教程。

再说一下,线上性能监控

对于线上性能监控,我们需要先明白两个原则:
1、监控代码不要侵入到业务代码中;
2、采用性能消耗最小的监控方案。

接下来我们从CPU使用率、FPS的帧率和内存这三个方面,说一下线上性能监控

CPU使用率的线上监控方法

App作为进程运行起来后会有多个线程,每个线程对CPU 的使用率不同。各个线程对CPU使用率的总和,就是当前App对CPU 的使用率。明白了这一点以后,我们也就摸清楚了对CPU使用率进行线上监控的思路。

在iOS系统中,你可以在 usr/include/mach/thread_info.h 里看到线程基本信息的结构体,其中的cpu_usage 就是 CPU使用率。结构体的完整代码如下所示:

struct thread_basic_info {
time_value_t user_time; // 用户运行时长
time_value_t system_time; // 系统运行时长
integer_t cpu_usage; // CPU 使用率
policy_t policy; // 调度策略
integer_t run_state; // 运行状态
integer_t flags; // 各种标记
integer_t suspend_count; // 暂停线程的计数
integer_t sleep_time; // 休眠的时间
};

因为每个线程都会有这个 thread_basic_info 结构体,所以接下来的事情就好办了,你只需要定时(比如,将定时间隔设置为2s)去遍历每个线程,累加每个线程的 cpu_usage 字段的值,就能够得到当前App所在进程的 CPU 使用率了。实现代码如下:

- (integer_t)cpuUsage {
thread_act_array_t threads; //int 组成的数组比如 thread[1] = 5635
mach_msg_type_number_t threadCount = 0; //mach_msg_type_number_t 是 int 类型
const task_t thisTask = mach_task_self();
//根据当前 task 获取所有线程
kern_return_t kr = task_threads(thisTask, &threads, &threadCount);

if (kr != KERN_SUCCESS) {
return 0;
}

integer_t cpuUsage = 0;
// 遍历所有线程
for (int i = 0; i < threadCount; i++) {

thread_info_data_t threadInfo;
thread_basic_info_t threadBaseInfo;
mach_msg_type_number_t threadInfoCount = THREAD_INFO_MAX;

if (thread_info((thread_act_t)threads[i], THREAD_BASIC_INFO, (thread_info_t)threadInfo, &threadInfoCount) == KERN_SUCCESS) {
// 获取 CPU 使用率
threadBaseInfo = (thread_basic_info_t)threadInfo;
if (!(threadBaseInfo->flags & TH_FLAGS_IDLE)) {
cpuUsage += threadBaseInfo->cpu_usage;
}
}
}
assert(vm_deallocate(mach_task_self(), (vm_address_t)threads, threadCount * sizeof(thread_t)) == KERN_SUCCESS);
return cpuUsage;
}

在上面这段代码中,task_threads 方法能够取到当前进程中的线程总数 threadCount 和所有线程的数组 threads。

接下来,我们就可以通过遍历这个数组来获取单个线程的基本信息。其中,线程基本信息的结构体是 thread_basic_info_t,这个结构体里就包含了我们需要的 CPU 使用率的字段 cpu_usage。然后,我们累加这个字段就能够获取到当前的整体 CPU 使用率。

接下来我们说说关于FPS的监控

FPS 线上监控方法

FPS 是指图像连续在显示设备上出现的频率。FPS低,表示App不够流畅,还需要进行优化。

但是,和前面对CPU使用率和内存使用量的监控不同,iOS系统中没有一个专门的结构体,用来记录与FPS相关的数据。但是,对FPS的监控也可以比较简单的实现:通过注册 CADisplayLink 得到屏幕的同步刷新率,记录每次刷新时间,然后就可以得到 FPS。具体的实现代码如下:

- (void)startMonitoring {
if (_link) {
[_link removeFromRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
[_link invalidate];
_link = nil;
}
_link = [CADisplayLink displayLinkWithTarget:self selector:@selector(fpsDisplayLinkAction:)];
[_link addToRunLoop:[NSRunLoop mainRunLoop] forMode:NSRunLoopCommonModes];
}

- (void)fpsDisplayLinkAction:(CADisplayLink *)link {
if (_lastTime == 0) {
_lastTime = link.timestamp;
return;
}

self.count++;
NSTimeInterval delta = link.timestamp - _lastTime;
if (delta < 1) return;
_lastTime = link.timestamp;
_fps = _count / delta;
NSLog(@"count = %d, delta = %f,_lastTime = %f, _fps = %.0f",_count, delta, _lastTime, _fps);
self.count = 0;
}


内存使用量的线上监控方法


通常情况下,我们在获取 iOS 应用内存使用量时,都是使用task_basic_info 里的 resident_size 字段信息。但是,我们发现这样获得的内存使用量和 Instruments 里看到的相差很大。后来,在 2018 WWDC Session 416 iOS Memory Deep Dive中,苹果公司介绍说 phys_footprint 才是实际使用的物理内存。


内存信息存在 task_info.h (完整路径 usr/include/mach/task.info.h)文件的 task_vm_info 结构体中,其中phys_footprint 就是物理内存的使用,而不是驻留内存 resident_size。结构体里和内存相关的代码如下:

struct task_vm_info {
mach_vm_size_t virtual_size; // 虚拟内存大小
integer_t region_count; // 内存区域的数量
integer_t page_size;
mach_vm_size_t resident_size; // 驻留内存大小
mach_vm_size_t resident_size_peak; // 驻留内存峰值

...

/* added for rev1 */
mach_vm_size_t phys_footprint; // 物理内存

...

我们只要从这个结构体里取出phys_footprint 字段的值,就能够监控到实际物理内存的使用情况了。具体实现代码如下:

- (unsigned long)memoryUsage {    
task_vm_info_data_t vmInfo;
mach_msg_type_number_t count = TASK_VM_INFO_COUNT;
kern_return_t result = task_info(mach_task_self(), TASK_VM_INFO, (task_info_t) &vmInfo, &count);
if (result != KERN_SUCCESS)
return 0;
return vmInfo.phys_footprint;
}

从以上三个线上性能监控方案可以看出,它们的代码和业务逻辑是完全解耦的,监控时基本都是直接获取系统本身提供的数据,没有额外的计算量,因此对 App 本身的性能影响也非常小,满足了我们要考虑的两个原则。

你可以点击这个链接,查看具体demo,欢迎大家点赞。

链接:https://www.jianshu.com/p/cc02a1e1e019

收起阅读 »

CocoaAsyncSocket源码分析---Connect (八)

Connect流程,用一张图来概括总结一下吧:socketchildSocketFD = accept(parentSocketFD, (struct sockaddr *)&addr, &addrLen); 然后调用了newSocketQue...
继续阅读 »

客户端的整个Connect流程,用一张图来概括总结一下吧:



整个客户端连接的流程大致如上图,当然远不及于此,这里我们对地址做了IPV4IPV6的兼容处理,对一些使用socket而产生的网络错误导致进程退出的容错处理。以及在这个过程中,socketQueue、代理queue、全局并发queuestream常驻线程的管理调度等等。

当然其中绝大部分操作都是在socketQueue中进行的。而在socketQueue中,我们也分为两种操作dispatch_syncdispatch_async
因为socketQueue本身就是一个串行queue,所以我们所有的操作都在这个queue中进行保证了线程安全,而需要阻塞后续行为的操作,我们用了sync的方式。其实这样使用sync是及其容易死锁的,但是作者每次在调用sync之前都调用了这么一行判断:

if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))

判断当前队列是否就是这个socketQueue队列,如果是则直接调用,否则就用sync的方式提交到这个queue中去执行。这种防死锁的方式,你学到了么?

接着我们来讲讲服务端Accept流程:

整个流程还是相对Connect来说还是十分简单的,因为这个方法很长,而且大多数是我们直接连接讲到过得内容,所以我省略了一部分的代码,只把重要的展示出来,大家可以参照着源码看。

//监听端口起点
- (BOOL)acceptOnPort:(uint16_t)port error:(NSError **)errPtr
{
return [self acceptOnInterface:nil port:port error:errPtr];
}

- (BOOL)acceptOnInterface:(NSString *)inInterface port:(uint16_t)port error:(NSError **)errPtr
{
LogTrace();

// Just in-case interface parameter is immutable.
//防止参数被修改
NSString *interface = [inInterface copy];

__block BOOL result = NO;
__block NSError *err = nil;

// CreateSocket Block
// This block will be invoked within the dispatch block below.
//创建socket的Block
int(^createSocket)(int, NSData*) = ^int (int domain, NSData *interfaceAddr) {

//创建TCP的socket
int socketFD = socket(domain, SOCK_STREAM, 0);

//一系列错误判断
...
// Bind socket
//用本地地址去绑定
status = bind(socketFD, (const struct sockaddr *)[interfaceAddr bytes], (socklen_t)[interfaceAddr length]);

//监听这个socket
//第二个参数是这个端口下维护的socket请求队列,最多容纳的用户请求数。
status = listen(socketFD, 1024);
return socketFD;
};

// Create dispatch block and run on socketQueue

dispatch_block_t block = ^{ @autoreleasepool {

//一系列错误判断
...

//判断ipv4 ipv6是否支持
...

//得到本机的IPV4 IPV6的地址
[self getInterfaceAddress4:&interface4 address6:&interface6 fromDescription:interface port:port];
...

//判断可以用IPV4还是6进行请求
...

// Create accept sources
//创建接受连接被触发的source
if (enableIPv4)
{
//接受连接的source
accept4Source = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socket4FD, 0, socketQueue);

//事件句柄
dispatch_source_set_event_handler(accept4Source, ^{ @autoreleasepool {

//拿到数据,连接数
unsigned long numPendingConnections = dispatch_source_get_data(acceptSource);

LogVerbose(@"numPendingConnections: %lu", numPendingConnections);

//循环去接受这些socket的事件(一次触发可能有多个连接)
while ([strongSelf doAccept:socketFD] && (++i < numPendingConnections));

}});

//取消句柄
dispatch_source_set_cancel_handler(accept4Source, ^{
//...
//关闭socket
close(socketFD);

});

//开启source
dispatch_resume(accept4Source);
}

//ipv6一样
...

//在scoketQueue中同步做这些初始化。
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
else
dispatch_sync(socketQueue, block);

//...错误判断
//返回结果
return result;
}

这个方法省略完仍然有这么长,它主要做了这两件事(篇幅原因,尽量精简):

  1. 创建本机地址、创建socket、绑定端口、监听端口。
  2. 创建了一个GCD Source,来监听这个socket读source,这样连接事件一发生,就会触发我们的事件句柄。接着我们调用了doAccept:方法循环去接受所有的连接。

接着我们来看这个接受连接的方法(同样省略了一部分不那么重要的代码):

//连接接受的方法
- (BOOL)doAccept:(int)parentSocketFD
{
LogTrace();

int socketType;
int childSocketFD;
NSData *childSocketAddress;

//IPV4
if (parentSocketFD == socket4FD)
{
socketType = 0;

struct sockaddr_in addr;
socklen_t addrLen = sizeof(addr);
//调用接受,得到接受的子socket
childSocketFD = accept(parentSocketFD, (struct sockaddr *)&addr, &addrLen);
//NO说明没有连接
if (childSocketFD == -1)
{
LogWarn(@"Accept failed with error: %@", [self errnoError]);
return NO;
}
//子socket的地址数据
childSocketAddress = [NSData dataWithBytes:&addr length:addrLen];
}
//一样
else if (parentSocketFD == socket6FD)
{
...
}
//unix domin socket 一样
else // if (parentSocketFD == socketUN)
{
...
}

//socket 配置项的设置... 和connect一样

//响应代理
if (delegateQueue)
{
__strong id theDelegate = delegate;
//代理队列中调用
dispatch_async(delegateQueue, ^{ @autoreleasepool {

// Query delegate for custom socket queue

dispatch_queue_t childSocketQueue = NULL;

//判断是否实现了为socket 生成一个新的SocketQueue,是的话拿到新queue
if ([theDelegate respondsToSelector:@selector(newSocketQueueForConnectionFromAddress:onSocket:)])
{
childSocketQueue = [theDelegate newSocketQueueForConnectionFromAddress:childSocketAddress
onSocket:self];
}

// Create GCDAsyncSocket instance for accepted socket
//新创建一个本类实例,给接受的socket
GCDAsyncSocket *acceptedSocket = [[[self class] alloc] initWithDelegate:theDelegate
delegateQueue:delegateQueue
socketQueue:childSocketQueue];
//IPV4 6 un
if (socketType == 0)
acceptedSocket->socket4FD = childSocketFD;
else if (socketType == 1)
acceptedSocket->socket6FD = childSocketFD;
else
acceptedSocket->socketUN = childSocketFD;
//标记开始 并且已经连接
acceptedSocket->flags = (kSocketStarted | kConnected);

// Setup read and write sources for accepted socket
//初始化读写source
dispatch_async(acceptedSocket->socketQueue, ^{ @autoreleasepool {

[acceptedSocket setupReadAndWriteSourcesForNewlyConnectedSocket:childSocketFD];
}});

//判断代理是否实现了didAcceptNewSocket方法,把我们新创建的socket返回出去
if ([theDelegate respondsToSelector:@selector(socket:didAcceptNewSocket:)])
{
[theDelegate socket:self didAcceptNewSocket:acceptedSocket];
}

}});
}
return YES;
}

  • 这个方法很简单,核心就是调用下面这个函数,去接受连接,并且拿到一个新的socket
childSocketFD = accept(parentSocketFD, (struct sockaddr *)&addr, &addrLen);

  • 然后调用了newSocketQueueForConnectionFromAddress:onSocket:这个代理,可以为新的socket重新设置一个socketQueue
  • 接着我们用这个Socket重新创建了一个GCDAsyncSocket实例,然后调用我们的代理didAcceptNewSocket方法,把这个实例给传出去了。
  • 这里需要注意的是,我们调用didAcceptNewSocket代理方法传出去的实例我们需要自己保留,不然就会被释放掉,那么这个与客户端的连接也就断开了。
  • 同时我们还初始化了这个新socket的读写source,这一步完全和connect中一样,调用同一个方法,这样如果有读写数据,就会触发这个新的socketsource了。

建立连接之后的无数个新的socket,都是独立的,它们处理读写连接断开的逻辑就和客户端socket完全一样了。
而我们监听本机端口的那个socket始终只有一个,这个用来监听触发socket连接,并返回创建我们这无数个新的socket实例。

作为服务端的Accept流程就这么结束了,因为篇幅原因,所以尽量精简了一些细节的处理,不过这些处理在Connect中也是反复出现的,所以基本无伤大雅。如果大家会感到困惑,建议下载github中的源码注释,对照着再看一遍,相信会有帮助的。


接着我们来讲讲Unix Domin Socket建立本地进程通信流程:

基本上这个流程,比上述任何流程还要简单,简单的到即使不简化代码,也没多少行(当然这是建立在客户端Connect流程已经实现了很多公用方法的基础上)。

接着进入正题,我们来看看它发起连接的方法:


//连接本机的url上,IPC,进程间通信
- (BOOL)connectToUrl:(NSURL *)url withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr;
{
LogTrace();

__block BOOL result = NO;
__block NSError *err = nil;

dispatch_block_t block = ^{ @autoreleasepool {

//判断长度
if ([url.path length] == 0)
{
NSString *msg = @"Invalid unix domain socket url.";
err = [self badParamError:msg];

return_from_block;
}

// Run through standard pre-connect checks
//前置的检查
if (![self preConnectWithUrl:url error:&err])
{
return_from_block;
}

// We've made it past all the checks.
// It's time to start the connection process.

flags |= kSocketStarted;

// Start the normal connection process

NSError *connectError = nil;
//调用另一个方法去连接
if (![self connectWithAddressUN:connectInterfaceUN error:&connectError])
{
[self closeWithError:connectError];

return_from_block;
}

[self startConnectTimeout:timeout];

result = YES;
}};

//在socketQueue中同步执行
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
else
dispatch_sync(socketQueue, block);

if (result == NO)
{
if (errPtr)
*errPtr = err;
}

return result;
}

连接方法非常简单,就只是做了一些错误的处理,然后调用了其他的方法,包括一个前置检查,这检查中会去判断各种参数是否正常,如果正常会返回YES,并且把url转换成Uinix domin socket地址的结构体,赋值给我们的属性connectInterfaceUN
接着调用了connectWithAddressUN方法去发起连接。

我们接着来看看这个方法:

//连接Unix域服务器
- (BOOL)connectWithAddressUN:(NSData *)address error:(NSError **)errPtr
{
LogTrace();

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");

// Create the socket

int socketFD;

LogVerbose(@"Creating unix domain socket");

//创建本机socket
socketUN = socket(AF_UNIX, SOCK_STREAM, 0);

socketFD = socketUN;

if (socketFD == SOCKET_NULL)
{
if (errPtr)
*errPtr = [self errnoErrorWithReason:@"Error in socket() function"];

return NO;
}

// Bind the socket to the desired interface (if needed)

LogVerbose(@"Binding socket...");

int reuseOn = 1;
//设置可复用
setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));

// Prevent SIGPIPE signals

int nosigpipe = 1;
//进程终止错误信号禁止
setsockopt(socketFD, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe, sizeof(nosigpipe));

// Start the connection process in a background queue

int aStateIndex = stateIndex;

dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(globalConcurrentQueue, ^{

const struct sockaddr *addr = (const struct sockaddr *)[address bytes];
//并行队列调用连接
int result = connect(socketFD, addr, addr->sa_len);
if (result == 0)
{
dispatch_async(socketQueue, ^{ @autoreleasepool {
//连接成功的一些状态初始化
[self didConnect:aStateIndex];
}});
}
else
{
// 失败的处理
perror("connect");
NSError *error = [self errnoErrorWithReason:@"Error in connect() function"];

dispatch_async(socketQueue, ^{ @autoreleasepool {

[self didNotConnect:aStateIndex error:error];
}});
}
});

LogVerbose(@"Connecting...");

return YES;
}

主要部分基本和客户端连接相同,并且简化了很多,调用了这一行完成了连接:

int result = connect(socketFD, addr, addr->sa_len);

同样也和客户端一样,在连接成功之后去调用下面这个方法完成了一些资源的初始化:

 [self didConnect:aStateIndex];

基本上连接就这么两个方法了(当然我们省略了一些细节),看完客户端的连接之后,到这就变得非常简单了。

接着我们来看看uinix domin socket作为服务端Accept。

这个Accpet,基本和我们普通Socket服务端的Accept相同。

//接受一个Url,uniex domin socket 做为服务端
- (BOOL)acceptOnUrl:(NSURL *)url error:(NSError **)errPtr;
{
LogTrace();

__block BOOL result = NO;
__block NSError *err = nil;

//基本和正常的socket accept一模一样
// CreateSocket Block
// This block will be invoked within the dispatch block below.
//生成一个创建socket的block,创建、绑定、监听
int(^createSocket)(int, NSData*) = ^int (int domain, NSData *interfaceAddr) {

//creat socket
...
// Set socket options

...
// Bind socket

...

// Listen
...
};

// Create dispatch block and run on socketQueue
//错误判断
dispatch_block_t block = ^{ @autoreleasepool {

//错误判断
...

//判断是否有这个url路径是否正确
...

//调用上面的Block创建socket,并且绑定监听。
...

//创建接受连接的source
acceptUNSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socketUN, 0, socketQueue);

int socketFD = socketUN;
dispatch_source_t acceptSource = acceptUNSource;
//事件句柄,和accpept一样
dispatch_source_set_event_handler(acceptUNSource, ^{ @autoreleasepool {
//循环去接受所有的每一个连接
...
}});

//取消句柄
dispatch_source_set_cancel_handler(acceptUNSource, ^{

//关闭socket
close(socketFD);
});

LogVerbose(@"dispatch_resume(accept4Source)");
dispatch_resume(acceptUNSource);

flags |= kSocketStarted;

result = YES;
}};

if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
else
dispatch_sync(socketQueue, block);
//填充错误
if (result == NO)
{
LogInfo(@"Error in accept: %@", err);

if (errPtr)
*errPtr = err;
}

return result;
}

因为代码基本雷同,所以我们省略了大部分代码,大家可以参照着之前的讲解或者源码去理解。这里和普通服务端socket唯一的区别就是,这里服务端绑定的地址是unix domin socket类型的地址,它是一个结构体,里面包含的是我们进行进程通信的纽带-一个本机文件路径。
所以这里服务端简单来说就是绑定的这个文件路径,当这个文件路径有数据可读(即有客户端连接到达)的时候,会触发初始化的source事件句柄,我们会去循环的接受所有的连接,并且新生成一个socket实例,这里和普通的socket完全一样。

就这样我们所有的连接方式已经讲完了,后面这两种方式,为了节省篇幅,确实讲的比较粗略,但是核心的部分都有提到。
另外如果你有理解客户端的Connect流程,那么理解起来应该没有什么问题,这两个流程比前者可简化太多了。


这个框架的Connect篇 全篇结束














收起阅读 »

CocoaAsyncSocket源码分析---Connect (七)

addStreamsToRunLoop这里方法做了两件事:CFStream读写回调的常驻线程,其中调用了好几个函数: + (void)startCFStreamThreadIfNeeded; + (void)cfstreamThread; 在这两个函数中,添...
继续阅读 »

接着我们来到流处理的第三步:addStreamsToRunLoop-添加到runloop上。

Stream相关方法三 -- 加到当前线程的runloop上:

//把stream添加到runloop上
- (BOOL)addStreamsToRunLoop
{
LogTrace();

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
NSAssert((readStream != NULL && writeStream != NULL), @"Read/Write stream is null");

//判断flag里是否包含kAddedStreamsToRunLoop,没添加过则添加。
if (!(flags & kAddedStreamsToRunLoop))
{
LogVerbose(@"Adding streams to runloop...");

[[self class] startCFStreamThreadIfNeeded];
//在开启的线程中去执行,阻塞式的
[[self class] performSelector:@selector(scheduleCFStreams:)
onThread:cfstreamThread
withObject:self
waitUntilDone:YES];

//添加标识
flags |= kAddedStreamsToRunLoop;
}

return YES;
}


这里方法做了两件事:

  1. 开启了一条用于CFStream读写回调的常驻线程,其中调用了好几个函数:
 + (void)startCFStreamThreadIfNeeded;
+ (void)cfstreamThread;

在这两个函数中,添加了一个runloop,并且绑定了一个定时器事件,让它run起来,使得线程常驻。

  1. 在这个常驻线程中去调用注册方法:
//注册CFStream
+ (void)scheduleCFStreams:(GCDAsyncSocket *)asyncSocket
{
LogTrace();

//断言当前线程是cfstreamThread,不是则报错
NSAssert([NSThread currentThread] == cfstreamThread, @"Invoked on wrong thread");

//获取到runloop
CFRunLoopRef runLoop = CFRunLoopGetCurrent();
//如果有readStream
if (asyncSocket->readStream)
//注册readStream在runloop的kCFRunLoopDefaultMode上
CFReadStreamScheduleWithRunLoop(asyncSocket->readStream, runLoop, kCFRunLoopDefaultMode);

//一样
if (asyncSocket->writeStream)
CFWriteStreamScheduleWithRunLoop(asyncSocket->writeStream, runLoop, kCFRunLoopDefaultMode);
}

这里可以看到,我们流的回调都是在这条流的常驻线程中,至于为什么要这么做,相信大家楼主看过AFNetworking系列文章的会明白。我们之后文章也会就这个框架线程的问题详细讨论的,这里就暂时不详细说明了。
这里主要用了CFReadStreamScheduleWithRunLoop函数完成了runloop的注册:

CFReadStreamScheduleWithRunLoop(asyncSocket->readStream, runLoop, kCFRunLoopDefaultMode);
CFWriteStreamScheduleWithRunLoop(asyncSocket->writeStream, runLoop, kCFRunLoopDefaultMode);

这样,如果stream中有我们监听的事件发生了,就会在这个runloop中触发我们之前设置的读写回调函数。

我们完成了注册,接下来我们就需要打开stream了:

Stream相关方法四 -- 打开stream:

//打开stream
- (BOOL)openStreams
{
LogTrace();

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
//断言读写stream都不会空
NSAssert((readStream != NULL && writeStream != NULL), @"Read/Write stream is null");

//返回stream的状态

CFStreamStatus readStatus = CFReadStreamGetStatus(readStream);
CFStreamStatus writeStatus = CFWriteStreamGetStatus(writeStream);

//如果有任意一个没有开启
if ((readStatus == kCFStreamStatusNotOpen) || (writeStatus == kCFStreamStatusNotOpen))
{
LogVerbose(@"Opening read and write stream...");

//开启
BOOL r1 = CFReadStreamOpen(readStream);
BOOL r2 = CFWriteStreamOpen(writeStream);

//有一个开启失败
if (!r1 || !r2)
{
LogError(@"Error in CFStreamOpen");
return NO;
}
}

return YES;
}

方法也很简单,通过CFReadStreamGetStatus函数,获取到当前stream的状态,判断没开启则调用CFReadStreamOpen函数去开启,如果开启失败,错误返回。

到这里stream初始化相关的工作就做完了,接着我们还是回到本文方法十一 -- 连接成功后的初始化中

其中第5条,我们谈到了设置socket的I/O模式为非阻塞,相信很多朋友对socket的I/O:同步、异步、阻塞、非阻塞。这四个概念有所混淆。
简单的来说,同步、异步是对于客户端而言的。比如我发起一个调用一个函数,我如果直接去调用,那么就是同步的,否则新开辟一个线程去做,那么对于当前线程而言就是异步的。
阻塞和非阻塞是对于服务端而言。当服务端被客户端调用后,我如果立刻返回调用的结果(无论数据是否处理完)那么就是非阻塞的,又或者等待数据拿到并且处理完(总之一系列逻辑)再返回,那么这种情况就是阻塞的。

好了,有了这个概念,我们接下来看看Linux下的5种I/O模型:
1)阻塞I/O(blocking I/O)
2)非阻塞I/O (nonblocking I/O)

  1. I/O复用(select 和poll) (I/O multiplexing)
    4)信号驱动I/O (signal driven I/O (SIGIO))
    5)异步I/O (asynchronous I/O (the POSIX aio_functions))

我们来简单谈谈这5种模型:
1)阻塞I/O:
简单举个例子,比如我们调用read()去读取消息,如果是在阻塞模式下,我们会一直等待,直到有消息到来为止。
很多小伙伴可能又要说了,这有什么不可以,我们新开辟一条线程,让它等着不就行了,看起来确实没什么不可以。
那是因为你仅仅是站在客户端的角度上来看。试想如果我们服务端也这么做,那岂不是有多少个socket连接,我们得开辟多少个线程去做阻塞IO?
2)非阻塞I/O
于是就有了非阻塞的概念,当我们去read()的时候,直接返回结果,这样在很大概率下,是并没有消息给我们读的。这时候函数就会错误返回-1,并将errno设置为 EWOULDBLOCK,意为IO并没有数据。
这时候就需要我们自己有一个机制,能知道什么时候有数据,在去调用read()。有一个很傻的方式就是不停的循环去调用这个函数,这样有数据来,我们第一时间就读到了。
3)I/O复用模式
I/O复用模式阻塞I/O的改进版,它在read之前,会先去调用select去遍历所有的socket,看哪一个有消息。当然这个过程是阻塞的,直到有消息返回为止。然后在去调用read,阻塞的方式去读取从系统内核中去读取这条消息到进程中来。
4)信号驱动I/O
信号驱动I/O是一个半异步的I/O模式,它首先会调用一个系统sginal相关的函数,把socket和信号绑定起来,然后不管有没有消息直接返回(这一步非阻塞)。这时候系统内核会去检查socket是否有可用数据。有的话则发送该信号给进程,然后进程在去调用read阻塞式的从系统内核读取数据到进程中来(这一步阻塞)。
5)可能聪明的你已经想到了更好的解决方式,这就对了,这就是我们第5种IO模式:异步I/O ,它和第4步一样,也是调用sginal相关函数,把socket和信号绑定起来,同时绑定起来的还有一块数据缓冲区buffer。然后无论有没有数据直接返回(非阻塞)。而系统内核会去检查是否有可用数据,一旦有可用数据,则触发信号,并且把数据填充到我们之前提供的数据缓冲区buffer中。这样我们进程被信号触发,并且直接能从buffer中读取到数据,整个过程没有任何阻塞。
很显然,我们CocoaAyncSocket框架用的就是第5种I/O模式。

接着我们继续看本文方法十一 -- 连接成功后的初始化中第6条,读写source的初始化方法:

本文方法十二 -- 初始化读写source:
//初始化读写source
- (void)setupReadAndWriteSourcesForNewlyConnectedSocket:(int)socketFD
{
//GCD source DISPATCH_SOURCE_TYPE_READ 会一直监视着 socketFD,直到有数据可读
readSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, socketFD, 0, socketQueue);
//_dispatch_source_type_write :监视着 socketFD,直到写数据了
writeSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_WRITE, socketFD, 0, socketQueue);

// Setup event handlers

__weak GCDAsyncSocket *weakSelf = self;

#pragma mark readSource的回调

//GCD事件句柄 读,当socket中有数据流出现,就会触发这个句柄,全自动,不需要手动触发
dispatch_source_set_event_handler(readSource, ^{ @autoreleasepool {
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"

__strong GCDAsyncSocket *strongSelf = weakSelf;
if (strongSelf == nil) return_from_block;

LogVerbose(@"readEventBlock");
//从readSource中,获取到数据长度,
strongSelf->socketFDBytesAvailable = dispatch_source_get_data(strongSelf->readSource);
LogVerbose(@"socketFDBytesAvailable: %lu", strongSelf->socketFDBytesAvailable);

//如果长度大于0,开始读数据
if (strongSelf->socketFDBytesAvailable > 0)
[strongSelf doReadData];
else
//因为触发了,但是却没有可读数据,说明读到当前包边界了。做边界处理
[strongSelf doReadEOF];

#pragma clang diagnostic pop
}});

//写事件句柄
dispatch_source_set_event_handler(writeSource, ^{ @autoreleasepool {
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"

__strong GCDAsyncSocket *strongSelf = weakSelf;
if (strongSelf == nil) return_from_block;

LogVerbose(@"writeEventBlock");
//标记为接受数据
strongSelf->flags |= kSocketCanAcceptBytes;
//开始写
[strongSelf doWriteData];

#pragma clang diagnostic pop
}});

// Setup cancel handlers

__block int socketFDRefCount = 2;

#if !OS_OBJECT_USE_OBJC
dispatch_source_t theReadSource = readSource;
dispatch_source_t theWriteSource = writeSource;
#endif

//读写取消的句柄
dispatch_source_set_cancel_handler(readSource, ^{
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"

LogVerbose(@"readCancelBlock");

#if !OS_OBJECT_USE_OBJC
LogVerbose(@"dispatch_release(readSource)");
dispatch_release(theReadSource);
#endif

if (--socketFDRefCount == 0)
{
LogVerbose(@"close(socketFD)");
//关闭socket
close(socketFD);
}

#pragma clang diagnostic pop
});

dispatch_source_set_cancel_handler(writeSource, ^{
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"

LogVerbose(@"writeCancelBlock");

#if !OS_OBJECT_USE_OBJC
LogVerbose(@"dispatch_release(writeSource)");
dispatch_release(theWriteSource);
#endif

if (--socketFDRefCount == 0)
{
LogVerbose(@"close(socketFD)");
//关闭socket
close(socketFD);
}

#pragma clang diagnostic pop
});

// We will not be able to read until data arrives.
// But we should be able to write immediately.

//设置未读数量为0
socketFDBytesAvailable = 0;
//把读挂起的状态移除
flags &= ~kReadSourceSuspended;

LogVerbose(@"dispatch_resume(readSource)");
//开启读source
dispatch_resume(readSource);

//标记为当前可接受数据
flags |= kSocketCanAcceptBytes;
//先把写source标记为挂起
flags |= kWriteSourceSuspended;
}


这个方法初始化了读写source,这个方法主要是GCD source运用

这里GCD Source相关的主要是下面这3个函数

//创建source
dispatch_source_create(dispatch_source_type_t type,
uintptr_t handle,
unsigned long mask,
dispatch_queue_t _Nullable queue);
//为source设置事件句柄
dispatch_source_set_event_handler(dispatch_source_t source,
dispatch_block_t _Nullable handler);
//为source设置取消句柄
dispatch_source_set_cancel_handler(dispatch_source_t source,
dispatch_block_t _Nullable handler);


相信大家用至少用过GCD定时器,接触过这3个函数,这里创建source的函数,根据参数type的不同,可以处理不同的事件:


这里我们用的是DISPATCH_SOURCE_TYPE_READDISPATCH_SOURCE_TYPE_WRITE这两个类型。标识如果handle如果有可读或者可写数据时,会触发我们的事件句柄。

  • 而这里初始化的读写事件句柄内容也很简单,就是去读写数据。
  • 而取消句柄也就是去关闭socket
  • 初始化完成后,我们开启了readSource,一旦有数据过来就触发了我们readSource事件句柄,就可以去监听的socket所分配的缓冲区中去读取数据了,而wirteSource初始化完是挂起的。
  • 除此之外我们还初始化了当前source的状态,用于我们后续的操作。

至此我们客户端的整个Connect流程结束了 ,下章概括总结一下Connect

CocoaAsyncSocket源码分析---Connect (二)

CocoaAsyncSocket源码分析---Connect (三)

CocoaAsyncSocket源码分析---Connect (四)

CocoaAsyncSocket源码分析---Connect (五)

CocoaAsyncSocket源码分析---Connect (六)

CocoaAsyncSocket源码分析---Connect (七)

CocoaAsyncSocket源码分析---Connect (八)


作者:Cooci
链接:https://www.jianshu.com/p/b264eff1f326




收起阅读 »

CocoaAsyncSocket源码分析---Connect (六)

本文方法十一 -- 连接成功后的初始化原因是为了线程安全和socket相关的操作必须在queue中被回调。这个方法基本上很简单,就是关于两个stream函数的调用:这个函数创建了一对读写stream,并且把stream与这个scoket做了绑定。相信用过的朋友...
继续阅读 »

我们接着来看看连接成功后,初始化的方法:

本文方法十一 -- 连接成功后的初始化

//连接成功后调用,设置一些连接成功的状态
- (void)didConnect:(int)aStateIndex
{
LogTrace();

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");

//状态不同
if (aStateIndex != stateIndex)
{
LogInfo(@"Ignoring didConnect, already disconnected");

// The connect operation has been cancelled.
// That is, socket was disconnected, or connection has already timed out.
return;
}

//kConnected合并到当前flag中
flags |= kConnected;
//停止连接超时
[self endConnectTimeout];

#if TARGET_OS_IPHONE
// The endConnectTimeout method executed above incremented the stateIndex.
//上面的endConnectTimeout,会导致stateIndex增加,所以需要重新赋值
aStateIndex = stateIndex;
#endif

// Setup read/write streams (as workaround for specific shortcomings in the iOS platform)
//
// Note:
// There may be configuration options that must be set by the delegate before opening the streams.
//打开stream之前必须用相关配置设置代理
// The primary example is the kCFStreamNetworkServiceTypeVoIP flag, which only works on an unopened stream.
//主要的例子是kCFStreamNetworkServiceTypeVoIP标记,只能工作在未打开的stream中?
//
// Thus we wait until after the socket:didConnectToHost:port: delegate method has completed.
//所以我们要等待,连接完成的代理调用完
// This gives the delegate time to properly configure the streams if needed.
//这些给了代理时间,去正确的配置Stream,如果是必要的话

//创建个Block来初始化Stream
dispatch_block_t SetupStreamsPart1 = ^{

NSLog(@"hello~");
#if TARGET_OS_IPHONE
//创建读写stream失败,则关闭并报对应错误
if (![self createReadAndWriteStream])
{
[self closeWithError:[self otherError:@"Error creating CFStreams"]];
return;
}

//参数是给NO的,就是有可读bytes的时候,不会调用回调函数
if (![self registerForStreamCallbacksIncludingReadWrite:NO])
{
[self closeWithError:[self otherError:@"Error in CFStreamSetClient"]];
return;
}

#endif
};
//part2设置stream
dispatch_block_t SetupStreamsPart2 = ^{
#if TARGET_OS_IPHONE
//状态不一样直接返回
if (aStateIndex != stateIndex)
{
// The socket has been disconnected.
return;
}
//如果加到runloop上失败
if (![self addStreamsToRunLoop])
{
//错误返回
[self closeWithError:[self otherError:@"Error in CFStreamScheduleWithRunLoop"]];
return;
}

//读写stream open
if (![self openStreams])
{
//开启错误返回
[self closeWithError:[self otherError:@"Error creating CFStreams"]];
return;
}

#endif
};

// Notify delegate
//通知代理
//拿到server端的host port
NSString *host = [self connectedHost];
uint16_t port = [self connectedPort];
//拿到unix域的 url
NSURL *url = [self connectedUrl];
//拿到代理
__strong id theDelegate = delegate;

//代理队列 和 Host不为nil 且响应didConnectToHost代理方法
if (delegateQueue && host != nil && [theDelegate respondsToSelector:@selector(socket:didConnectToHost:port:)])
{
//调用初始化stream1
SetupStreamsPart1();

dispatch_async(delegateQueue, ^{ @autoreleasepool {

//到代理队列调用连接成功的代理方法
[theDelegate socket:self didConnectToHost:host port:port];

//然后回到socketQueue中去执行初始化stream2
dispatch_async(socketQueue, ^{ @autoreleasepool {

SetupStreamsPart2();
}});
}});
}
//这个是unix domain 请求回调
else if (delegateQueue && url != nil && [theDelegate respondsToSelector:@selector(socket:didConnectToUrl:)])
{
SetupStreamsPart1();

dispatch_async(delegateQueue, ^{ @autoreleasepool {

[theDelegate socket:self didConnectToUrl:url];

dispatch_async(socketQueue, ^{ @autoreleasepool {

SetupStreamsPart2();
}});
}});
}
//否则只初始化stream
else
{
SetupStreamsPart1();
SetupStreamsPart2();
}

// Get the connected socket

int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : (socket6FD != SOCKET_NULL) ? socket6FD : socketUN;

//fcntl,功能描述:根据文件描述词来操作文件的特性。http://blog.csdn.net/pbymw8iwm/article/details/7974789
// Enable non-blocking IO on the socket
//使socket支持非阻塞IO
int result = fcntl(socketFD, F_SETFL, O_NONBLOCK);
if (result == -1)
{
//失败 ,报错
NSString *errMsg = @"Error enabling non-blocking IO on socket (fcntl)";
[self closeWithError:[self otherError:errMsg]];

return;
}

// Setup our read/write sources
//初始化读写source
[self setupReadAndWriteSourcesForNewlyConnectedSocket:socketFD];

// Dequeue any pending read/write requests
//开始下一个任务
[self maybeDequeueRead];
[self maybeDequeueWrite];
}

这个方法很长一大串,其实做的东西也很简单,主要做了下面几件事:

  1. 把当前状态flags加上已连接,并且关闭掉我们一开始连接开启的,连接超时的定时器。
  2. 初始化了两个BlockSetupStreamsPart1SetupStreamsPart2,这两个Block做的事都和读写流有关。SetupStreamsPart1用来创建读写流,并且注册回调。另一个SetupStreamsPart2用来把流添加到当前线程的runloop上,并且打开流。
  3. 判断是否有代理queuehost或者url这些参数是否为空、是否代理响应didConnectToHostdidConnectToUrl代理,这两种分别对应了普通socket连接和unix domin socket连接。如果实现了对应的代理,则调用连接成功的代理。
  4. 在调用代理的同时,调用了我们之前初始化的两个读写流相关的Block。这里值得说下的是这两个Block和代理之间的调用顺序:
  • 先执行SetupStreamsPart1后执行SetupStreamsPart2,没什么好说的,问题是代理的执行时间,想想如果我们放在SetupStreamsPart2后面是不是会导致个问题,就是用户收到消息了,但是连接成功的代理还没有被调用,这显然是不合理的。所以我们的调用顺序是SetupStreamsPart1->代理->SetupStreamsPart2

    所以出现了如下代码:


作者:Cooci
链接:https://www.jianshu.com/p/b264eff1f326
  //调用初始化stream1
SetupStreamsPart1();

dispatch_async(delegateQueue, ^{ @autoreleasepool {

//到代理队列调用连接成功的代理方法
[theDelegate socket:self didConnectToHost:host port:port];

//然后回到socketQueue中去执行初始化stream2
dispatch_async(socketQueue, ^{ @autoreleasepool {

SetupStreamsPart2();
}});
}});


原因是为了线程安全和socket相关的操作必须在socketQueue中进行。而代理必须在我们设置的代理queue中被回调。

  1. 拿到当前的本机socket,调用如下函数:
int result = fcntl(socketFD, F_SETFL, O_NONBLOCK);


而在这里,就是为了把socket的IO模式设置为非阻塞。很多小伙伴又要疑惑什么是非阻塞了,先别急,关于这个我们下文会详细的来谈。

  1. 我们初始化了读写source(很重要,所有的消息都是由这个source来触发的,我们之后会详细分析这个方法)。

  2. 我们做完了streamsource的初始化处理,则开始做一次读写任务(这两个方法暂时不讲,会放到之后的ReadWrite篇中去讲)。

我们接着来讲讲这个方法中对其他方法的调用,按照顺序来,先从第2条,两个Block中对stream的处理开始。和stream相关的函数一共有6个:

Stream相关方法一 -- 创建读写stream

//创建读写stream
- (BOOL)createReadAndWriteStream
{
LogTrace();

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");

//如果有一个有值,就返回
if (readStream || writeStream)
{
// Streams already created
return YES;
}
//拿到socket,首选是socket4FD,其次socket6FD,都没有才是socketUN,socketUN应该是Unix的socket结构体
int socketFD = (socket4FD != SOCKET_NULL) ? socket4FD : (socket6FD != SOCKET_NULL) ? socket6FD : socketUN;

//如果都为空,返回NO
if (socketFD == SOCKET_NULL)
{
// Cannot create streams without a file descriptor
return NO;
}

//如果非连接,返回NO
if (![self isConnected])
{
// Cannot create streams until file descriptor is connected
return NO;
}

LogVerbose(@"Creating read and write stream...");

#pragma mark - 绑定Socket和CFStream
//下面的接口用于创建一对 socket stream,一个用于读取,一个用于写入:
CFStreamCreatePairWithSocket(NULL, (CFSocketNativeHandle)socketFD, &readStream, &writeStream);

// The kCFStreamPropertyShouldCloseNativeSocket property should be false by default (for our case).
// But let's not take any chances.

//读写stream都设置成不会随着绑定的socket一起close,release。 kCFBooleanFalse不一起,kCFBooleanTrue一起
if (readStream)
CFReadStreamSetProperty(readStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
if (writeStream)
CFWriteStreamSetProperty(writeStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);

//如果有一个为空
if ((readStream == NULL) || (writeStream == NULL))
{
LogWarn(@"Unable to create read and write stream...");

//关闭对应的stream
if (readStream)
{
CFReadStreamClose(readStream);
CFRelease(readStream);
readStream = NULL;
}
if (writeStream)
{
CFWriteStreamClose(writeStream);
CFRelease(writeStream);
writeStream = NULL;
}
//返回创建失败
return NO;
}
//创建成功
return YES;
}

这个方法基本上很简单,就是关于两个stream函数的调用:

  1. 创建stream的函数:
CFStreamCreatePairWithSocket(NULL, (CFSocketNativeHandle)socketFD, &readStream, &writeStream);

这个函数创建了一对读写stream,并且把stream与这个scoket做了绑定。

  1. 设置stream属性:
CFReadStreamSetProperty(readStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);
CFWriteStreamSetProperty(writeStream, kCFStreamPropertyShouldCloseNativeSocket, kCFBooleanFalse);

这个函数可以给stream设置一个属性,这里是设置stream不会随着socket的生命周期(close,release)而变化。

接着调用了registerForStreamCallbacksIncludingReadWrite来给stream注册读写回调。

Stream相关方法二 -- 读写回调的注册:

//注册Stream的回调
- (BOOL)registerForStreamCallbacksIncludingReadWrite:(BOOL)includeReadWrite
{
LogVerbose(@"%@ %@", THIS_METHOD, (includeReadWrite ? @"YES" : @"NO"));

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
//判断读写stream是不是都为空
NSAssert((readStream != NULL && writeStream != NULL), @"Read/Write stream is null");

//客户端stream上下文对象
streamContext.version = 0;
streamContext.info = (__bridge void *)(self);
streamContext.retain = nil;
streamContext.release = nil;
streamContext.copyDescription = nil;

// The open has completed successfully.
// The stream has bytes to be read.
// The stream can accept bytes for writing.
// An error has occurred on the stream.
// The end of the stream has been reached.

//设置一个CF的flag 两种,一种是错误发生的时候,一种是stream事件结束
CFOptionFlags readStreamEvents = kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered ;
//如果包含读写
if (includeReadWrite)
//仍然有Bytes要读的时候 The stream has bytes to be read.
readStreamEvents |= kCFStreamEventHasBytesAvailable;

//给读stream设置客户端,会在之前设置的那些标记下回调函数 CFReadStreamCallback。设置失败的话直接返回NO
if (!CFReadStreamSetClient(readStream, readStreamEvents, &CFReadStreamCallback, &streamContext))
{
return NO;
}

//写的flag,也一样
CFOptionFlags writeStreamEvents = kCFStreamEventErrorOccurred | kCFStreamEventEndEncountered;
if (includeReadWrite)
writeStreamEvents |= kCFStreamEventCanAcceptBytes;

if (!CFWriteStreamSetClient(writeStream, writeStreamEvents, &CFWriteStreamCallback, &streamContext))
{
return NO;
}
//走到最后说明读写都设置回调成功,返回YES
return YES;
}

相信用过CFStream的朋友,应该会觉得很简单,这个方法就是调用了一些CFStream相关函数,其中最主要的这个设置读写回调函数:
Boolean CFReadStreamSetClient(CFReadStreamRef stream, CFOptionFlags streamEvents, CFReadStreamClientCallBack clientCB, CFStreamClientContext *clientContext);
Boolean CFWriteStreamSetClient(CFWriteStreamRef stream, CFOptionFlags streamEvents, CFWriteStreamClientCallBack clientCB, CFStreamClientContext *clientContext);


这个函数共4个参数:
第1个为我们需要设置的stream;
第2个为需要监听的事件选项,包括以下事件:

typedef CF_OPTIONS(CFOptionFlags, CFStreamEventType) {
kCFStreamEventNone = 0, //没有事件发生
kCFStreamEventOpenCompleted = 1, //成功打开流
kCFStreamEventHasBytesAvailable = 2, //流中有数据可读
kCFStreamEventCanAcceptBytes = 4, //流中可以接受数据去写
kCFStreamEventErrorOccurred = 8, //流发生错误
kCFStreamEventEndEncountered = 16 //到达流的结尾
};

其中具体用法,大家可以自行去试试,这里作者只监听了了两种事件kCFStreamEventErrorOccurredkCFStreamEventEndEncountered,再根据传过来的参数去决定是否监听kCFStreamEventCanAcceptBytes

//如果包含读写
if (includeReadWrite)
//仍然有Bytes要读的时候 The stream has bytes to be read.
readStreamEvents |= kCFStreamEventHasBytesAvailable;

而这里我们传过来的参数为NO,导致它并不监听可读数据。显然,我们正常的连接,当有消息发送过来,并不是由stream回调来触发的。这个框架中,如果是TLS传输的socket是用stream来触发的,这个我们后续文章会讲到。

那么有数据的时候,到底是什么来触发我们的读写呢,答案就是读写source,我们接下来就会去创建初始化它。

这里绑定了两个函数,分别对应读和写的回调,分别为:

//读的回调
static void CFReadStreamCallback (CFReadStreamRef stream, CFStreamEventType type, void *pInfo)
//写的回调
static void CFWriteStreamCallback (CFWriteStreamRef stream, CFStreamEventType type, void *pInfo)

关于这两个函数,同样这里暂时不做讨论,等后续文章再来分析。

还有一点需要说一下的是streamContext这个属性,它是一个结构体,包含流的上下文信息,其结构如下:

typedef struct {
CFIndex version;
void *info;
void *(*retain)(void *info);
void (*release)(void *info);
CFStringRef (*copyDescription)(void *info);
} CFStreamClientContext;


这个流的上下文中info指针,其实就是前面所对应的读写回调函数中的pInfo指针,每次回调都会传过去。其它的version就是流的版本标识,之外的3个都需要的是一个函数指针,对应我们传递的pInfo的持有以及释放还有复制的描述信息,这里我们都赋值给nil

下一章我们来到流处理的第三步


CocoaAsyncSocket源码分析---Connect (一)
CocoaAsyncSocket源码分析---Connect (八)
作者:Cooci
链接:https://www.jianshu.com/p/b264eff1f326







收起阅读 »

CocoaAsyncSocket源码分析---Connect (五)

上文我们提到了GCDAsyncSocket的初始化,以及最终connect之前的准备工作,包括一些错误检查;本机地址创建以及socket创建;服务端地址的创建;还有一些本机socket可选项的配置,例如禁止网络出错导致进程关闭的信号等我们去用之前创建的本机地址...
继续阅读 »
上文我们提到了GCDAsyncSocket的初始化,以及最终connect之前的准备工作,包括一些错误检查;本机地址创建以及socket创建;服务端地址的创建;还有一些本机socket可选项的配置,例如禁止网络出错导致进程关闭的信号等

言归正传,继续上文往下讲
上文讲到了本文方法八--创建Socket,其中有这么一行代码:
//和connectInterface绑定
if (![self bindSocket:socketFD toInterface:connectInterface error:errPtr])
{
//绑定失败,直接关闭返回
[self closeSocket:socketFD];

return SOCKET_NULL;
}

我们去用之前创建的本机地址去做socket绑定,接着会调用到如下方法中:

本文方法九--给Socket绑定本机地址
//绑定一个Socket的本地地址
- (BOOL)bindSocket:(int)socketFD toInterface:(NSData *)connectInterface error:(NSError **)errPtr
{
// Bind the socket to the desired interface (if needed)
//无接口就不绑定,connect会自动绑定到一个不冲突的端口上去。
if (connectInterface)
{
LogVerbose(@"Binding socket...");

//判断当前地址的Port是不是大于0
if ([[self class] portFromAddress:connectInterface] > 0)
{
// Since we're going to be binding to a specific port,
// we should turn on reuseaddr to allow us to override sockets in time_wait.

int reuseOn = 1;

//设置调用close(socket)后,仍可继续重用该socket。调用close(socket)一般不会立即关闭socket,而经历TIME_WAIT的过程。
setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));
}

//拿到地址
const struct sockaddr *interfaceAddr = (const struct sockaddr *)[connectInterface bytes];
//绑定这个地址
int result = bind(socketFD, interfaceAddr, (socklen_t)[connectInterface length]);

//绑定出错,返回NO
if (result != 0)
{
if (errPtr)
*errPtr = [self errnoErrorWithReason:@"Error in bind() function"];

return NO;
}
}

//成功
return YES;
}

这个方法也非常简单,如果没有connectInterface则直接返回YES,当socket进行连接的时候,会自动绑定一个端口,进行连接。
如果有值,则我们开始绑定到我们一开始指定的地址上。
这里调用了两个和scoket相关的函数:
第一个是我们之前提到的配置scoket参数的函数:

setsockopt(socketFD, SOL_SOCKET, SO_REUSEADDR, &reuseOn, sizeof(reuseOn));

这里调用这个函数的主要目的是为了调用close的时候,不立即去关闭socket连接,而是经历一个TIME_WAIT过程。在这个过程中,socket是可以被复用的。我们注意到之前的connect流程并没有看到复用socket的代码。注意,我们现在走的连接流程是客户端的流程,等我们讲到服务端accept进行连接的时候,我们就能看到这个复用的作用了。

第二个是bind函数
int result = bind(socketFD, interfaceAddr, (socklen_t)[connectInterface length]);

这个函数倒是很简单,就3个参数,socket、需要绑定的地址、地址大小。这样就把socket和这个地址(其实就是端口)捆绑在一起了。

这样我们就做完了最终连接前所有准备工作,本机socket有了,服务端的地址也有了。接着我们就可以开始进行最终连接了:

本文方法十 -- 建立连接的最终方法

//连接最终方法 3 finnal。。。
- (void)connectSocket:(int)socketFD address:(NSData *)address stateIndex:(int)aStateIndex
{
// If there already is a socket connected, we close socketFD and return
//已连接,关闭连接返回
if (self.isConnected)
{
[self closeSocket:socketFD];
return;
}

// Start the connection process in a background queue
//开始连接过程,在后台queue中
__weak GCDAsyncSocket *weakSelf = self;

//获取到全局Queue
dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//新线程
dispatch_async(globalConcurrentQueue, ^{
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"
//调用connect方法,该函数阻塞线程,所以要异步新线程
//客户端向特定网络地址的服务器发送连接请求,连接成功返回0,失败返回 -1。
int result = connect(socketFD, (const struct sockaddr *)[address bytes], (socklen_t)[address length]);

//老样子,安全判断
__strong GCDAsyncSocket *strongSelf = weakSelf;
if (strongSelf == nil) return_from_block;

//在socketQueue中,开辟线程
dispatch_async(strongSelf->socketQueue, ^{ @autoreleasepool {
//如果状态为已经连接,关闭连接返回
if (strongSelf.isConnected)
{
[strongSelf closeSocket:socketFD];
return_from_block;
}

//说明连接成功
if (result == 0)
{
//关闭掉另一个没用的socket
[self closeUnusedSocket:socketFD];
//调用didConnect,生成stream,改变状态等等!
[strongSelf didConnect:aStateIndex];
}
//连接失败
else
{
//关闭当前socket
[strongSelf closeSocket:socketFD];

// If there are no more sockets trying to connect, we inform the error to the delegate
//返回连接错误的error
if (strongSelf.socket4FD == SOCKET_NULL && strongSelf.socket6FD == SOCKET_NULL)
{
NSError *error = [strongSelf errnoErrorWithReason:@"Error in connect() function"];
[strongSelf didNotConnect:aStateIndex error:error];
}
}
}});

#pragma clang diagnostic pop
});
//输出正在连接中
LogVerbose(@"Connecting...");
}

这个方法主要就是做了一件事,调用下面一个函数进行连接:
int result = connect(socketFD, (const struct sockaddr *)[address bytes], (socklen_t)[address length]);


这里需要注意的是这个函数是阻塞,直到结果返回之前,线程会一直停在这行。所以这里用的是全局并发队列,开辟了一个新的线程进行连接,在得到结果之后,又调回socketQueue中进行后续操作。

如果result为0,说明连接成功,我们会关闭掉另外一个没有用到的socket(如果有的话)。然后调用另外一个方法做一些连接成功的初始化操作。
否则连接失败,我们会关闭socket,填充错误并且返回。

我们下一章来看看连接成功后初始化的方法


CocoaAsyncSocket源码分析---Connect (一)
CocoaAsyncSocket源码分析---Connect (八)
作者:Cooci
链接:https://www.jianshu.com/p/b264eff1f326





收起阅读 »

CocoaAsyncSocket源码分析---Connect (四)

//根据host、port + (NSMutableArray *)lookupHost:(NSString *)host port:(uint16_t)port error:(NSError **)errPtr { LogTrace(); ...
继续阅读 »
本文方法五--创建服务端server地址数据:

//根据host、port
+ (NSMutableArray *)lookupHost:(NSString *)host port:(uint16_t)port error:(NSError **)errPtr
{
LogTrace();

NSMutableArray *addresses = nil;
NSError *error = nil;

//如果Host是这localhost或者loopback
if ([host isEqualToString:@"localhost"] || [host isEqualToString:@"loopback"])
{
// Use LOOPBACK address
struct sockaddr_in nativeAddr4;
nativeAddr4.sin_len = sizeof(struct sockaddr_in);
nativeAddr4.sin_family = AF_INET;
nativeAddr4.sin_port = htons(port);
nativeAddr4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
//占位置0
memset(&(nativeAddr4.sin_zero), 0, sizeof(nativeAddr4.sin_zero));

//ipv6
struct sockaddr_in6 nativeAddr6;
nativeAddr6.sin6_len = sizeof(struct sockaddr_in6);
nativeAddr6.sin6_family = AF_INET6;
nativeAddr6.sin6_port = htons(port);
nativeAddr6.sin6_flowinfo = 0;
nativeAddr6.sin6_addr = in6addr_loopback;
nativeAddr6.sin6_scope_id = 0;

// Wrap the native address structures

NSData *address4 = [NSData dataWithBytes:&nativeAddr4 length:sizeof(nativeAddr4)];
NSData *address6 = [NSData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)];

//两个添加进数组
addresses = [NSMutableArray arrayWithCapacity:2];
[addresses addObject:address4];
[addresses addObject:address6];
}
else
{
//拿到port String
NSString *portStr = [NSString stringWithFormat:@"%hu", port];

//定义三个addrInfo 是一个sockaddr结构的链表而不是一个地址清单

struct addrinfo hints, *res, *res0;

//初始化为0
memset(&hints, 0, sizeof(hints));

//相当于 AF_UNSPEC ,返回的是适用于指定主机名和服务名且适合任何协议族的地址。
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;

//根据host port,去获取地址信息。

int gai_error = getaddrinfo([host UTF8String], [portStr UTF8String], &hints, &res0);

//出错
if (gai_error)
{ //获取到错误
error = [self gaiError:gai_error];
}
//正确获取到addrInfo
else
{
//
NSUInteger capacity = 0;
//遍历 res0
for (res = res0; res; res = res->ai_next)
{
//如果有IPV4 IPV6的,capacity+1
if (res->ai_family == AF_INET || res->ai_family == AF_INET6) {
capacity++;
}
}
//生成一个地址数组,数组为capacity大小
addresses = [NSMutableArray arrayWithCapacity:capacity];

//再去遍历,为什么不一次遍历完,仅仅是为了限制数组的大小?
for (res = res0; res; res = res->ai_next)
{
//IPV4
if (res->ai_family == AF_INET)
{
// Found IPv4 address.
// Wrap the native address structure, and add to results.
//加到数组中
NSData *address4 = [NSData dataWithBytes:res->ai_addr length:res->ai_addrlen];
[addresses addObject:address4];
}
else if (res->ai_family == AF_INET6)
{
// Fixes connection issues with IPv6
// https://github.com/robbiehanson/CocoaAsyncSocket/issues/429#issuecomment-222477158

// Found IPv6 address.
// Wrap the native address structure, and add to results.
//强转
struct sockaddr_in6 *sockaddr = (struct sockaddr_in6 *)res->ai_addr;
//拿到port
in_port_t *portPtr = &sockaddr->sin6_port;
//如果Port为0
if ((portPtr != NULL) && (*portPtr == 0)) {
//赋值,用传进来的port
*portPtr = htons(port);
}
//添加到数组
NSData *address6 = [NSData dataWithBytes:res->ai_addr length:res->ai_addrlen];
[addresses addObject:address6];
}
}
//对应getaddrinfo 释放内存
freeaddrinfo(res0);

//如果地址里一个没有,报错 EAI_FAIL:名字解析中不可恢复的失败
if ([addresses count] == 0)
{
error = [self gaiError:EAI_FAIL];
}
}
}
//赋值错误
if (errPtr) *errPtr = error;
//返回地址
return addresses;
}

这个方法根据host进行了划分:

  1. 如果hostlocalhost或者loopback,则按照我们之前绑定本机地址那一套生成地址的方式,去生成IPV4和IPV6的地址,并且用NSData包裹住这个地址结构体,装在NSMutableArray中。
  2. 不是本机地址,那么我们就需要根据host和port去创建地址了,这里用到的是这么一个函数:
int getaddrinfo( const char *hostname, const char *service, const struct addrinfo *hints, struct addrinfo **result );


这个函数主要的作用是:根据hostname(IP)service(port),去获取地址信息,并且把地址信息传递到result中。
而hints这个参数可以是一个空指针,也可以是一个指向某个addrinfo结构体的指针,如果填了,其实它就是一个配置参数,返回的地址信息会和这个配置参数的内容有关,如下例:

举例来说:指定的服务既可支持TCP也可支持UDP,所以调用者可以把hints结构中的ai_socktype成员设置成SOCK_DGRAM使得返回的仅仅是适用于数据报套接口的信息。

这里我们可以看到result和hints这两个参数指针指向的都是一个addrinfo的结构体,这是我们继上面以来看到的第4种地址结构体了。它的定义如下:


struct addrinfo {
int ai_flags; /* AI_PASSIVE, AI_CANONNAME, AI_NUMERICHOST */
int ai_family; /* PF_xxx */
int ai_socktype; /* SOCK_xxx */
int ai_protocol; /* 0 or IPPROTO_xxx for IPv4 and IPv6 */
socklen_t ai_addrlen; /* length of ai_addr */
char *ai_canonname; /* canonical name for hostname */
struct sockaddr *ai_addr; /* binary address */
struct addrinfo *ai_next; /* next structure in linked list */
};

我们可以看到它其中包括了一个IPV4的结构体地址ai_addr,还有一个指向下一个同类型数据节点的指针ai_next

这里讲讲ai_next这个指针,因为我们是去获取server端的地址,所以很可能有不止一个地址,比如IPV4、IPV6,又或者我们之前所说的一个服务器有多个网卡,这时候可能就会有多个地址。这些地址就会用ai_next指针串联起来,形成一个单链表。

然后我们拿到这个地址链表,去遍历它,对应取出IPV4、IPV6的地址,封装成NSData并装到数组中去。

  1. 如果中间有错误,赋值错误,返回地址数组,理清楚这几个结构体与函数,这个方法还是相当容易读的,具体的细节可以看看注释。

接着我们回到本文方法二,就要用这个地址数组去做连接了。


//异步去发起连接
dispatch_async(strongSelf->socketQueue, ^{ @autoreleasepool {

[strongSelf lookup:aStateIndex didSucceedWithAddress4:address4 address6:address6];
}});

这里调用了我们本文方法六--开始连接的方法1
//连接的最终方法 1
- (void)lookup:(int)aStateIndex didSucceedWithAddress4:(NSData *)address4 address6:(NSData *)address6
{
LogTrace();

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");
//至少有一个server地址
NSAssert(address4 || address6, @"Expected at least one valid address");

//如果状态不一致,说明断开连接
if (aStateIndex != stateIndex)
{
LogInfo(@"Ignoring lookupDidSucceed, already disconnected");

// The connect operation has been cancelled.
// That is, socket was disconnected, or connection has already timed out.
return;
}

// Check for problems
//分开判断。
BOOL isIPv4Disabled = (config & kIPv4Disabled) ? YES : NO;
BOOL isIPv6Disabled = (config & kIPv6Disabled) ? YES : NO;

if (isIPv4Disabled && (address6 == nil))
{
NSString *msg = @"IPv4 has been disabled and DNS lookup found no IPv6 address.";

[self closeWithError:[self otherError:msg]];
return;
}

if (isIPv6Disabled && (address4 == nil))
{
NSString *msg = @"IPv6 has been disabled and DNS lookup found no IPv4 address.";

[self closeWithError:[self otherError:msg]];
return;
}

// Start the normal connection process

NSError *err = nil;
//调用连接方法,如果失败,则错误返回
if (![self connectWithAddress4:address4 address6:address6 error:&err])
{
[self closeWithError:err];
}
}

这个方法也比较简单,基本上就是做了一些错误的判断。比如:

  1. 判断在不在这个socket队列。
  2. 判断传过来的aStateIndex和属性stateIndex是不是同一个值。说到这个值,不得不提的是大神用的框架,在容错处理上,做的真不是一般的严谨。从这个stateIndex上就能略见一二。
    这个aStateIndex是我们之前调用方法,用属性传过来的,所以按道理说,是肯定一样的。但是就怕在调用过程中,这个值发生了改变,这时候整个socket配置也就完全不一样了,有可能我们已经置空地址、销毁socket、断开连接等等...等我们后面再来看这个属性stateIndex在什么地方会发生改变。
  3. 判断config中是需要哪种配置,它的参数对应了一个枚举:

enum GCDAsyncSocketConfig
{
kIPv4Disabled = 1 << 0, // If set, IPv4 is disabled
kIPv6Disabled = 1 << 1, // If set, IPv6 is disabled
kPreferIPv6 = 1 << 2, // If set, IPv6 is preferred over IPv4
kAllowHalfDuplexConnection = 1 << 3, // If set, the socket will stay open even if the read stream closes
};

前3个大家很好理解,无非就是用IPV4还是IPV6。
而第4个官方注释意思是,我们即使关闭读的流,也会保持Socket开启。至于具体是什么意思,我们先不在这里讨论,等后文再说。

这里调用了我们本文方法七--开始连接的方法2

//连接最终方法 2。用两个Server地址去连接,失败返回NO,并填充error
- (BOOL)connectWithAddress4:(NSData *)address4 address6:(NSData *)address6 error:(NSError **)errPtr
{
LogTrace();

NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");

//输出一些东西?
LogVerbose(@"IPv4: %@:%hu", [[self class] hostFromAddress:address4], [[self class] portFromAddress:address4]);
LogVerbose(@"IPv6: %@:%hu", [[self class] hostFromAddress:address6], [[self class] portFromAddress:address6]);

// Determine socket type

//判断是否倾向于IPV6
BOOL preferIPv6 = (config & kPreferIPv6) ? YES : NO;

// Create and bind the sockets

//如果有IPV4地址,创建IPV4 Socket
if (address4)
{
LogVerbose(@"Creating IPv4 socket");

socket4FD = [self createSocket:AF_INET connectInterface:connectInterface4 errPtr:errPtr];
}
//如果有IPV6地址,创建IPV6 Socket
if (address6)
{
LogVerbose(@"Creating IPv6 socket");

socket6FD = [self createSocket:AF_INET6 connectInterface:connectInterface6 errPtr:errPtr];
}

//如果都为空,直接返回
if (socket4FD == SOCKET_NULL && socket6FD == SOCKET_NULL)
{
return NO;
}

//主选socketFD,备选alternateSocketFD
int socketFD, alternateSocketFD;
//主选地址和备选地址
NSData *address, *alternateAddress;

//IPV6
if ((preferIPv6 && socket6FD) || socket4FD == SOCKET_NULL)
{
socketFD = socket6FD;
alternateSocketFD = socket4FD;
address = address6;
alternateAddress = address4;
}
//主选IPV4
else
{
socketFD = socket4FD;
alternateSocketFD = socket6FD;
address = address4;
alternateAddress = address6;
}
//拿到当前状态
int aStateIndex = stateIndex;
//用socket和address去连接
[self connectSocket:socketFD address:address stateIndex:aStateIndex];

//如果有备选地址
if (alternateAddress)
{
//延迟去连接备选的地址
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(alternateAddressDelay * NSEC_PER_SEC)), socketQueue, ^{
[self connectSocket:alternateSocketFD address:alternateAddress stateIndex:aStateIndex];
});
}

return YES;
}

这个方法也仅仅是连接中过渡的一个方法,做的事也非常简单:

  1. 就是拿到IPV4和IPV6地址,先去创建对应的socket,注意这个socket是本机客户端的,和server端没有关系。这里服务端的IPV4和IPV6地址仅仅是用来判断是否需要去创建对应的本机Socket。这里去创建socket会带上我们之前生成的本地地址信息connectInterface4或者connectInterface6
  2. 根据我们的config配置,得到主选连接和备选连接。 然后先去连接主选连接地址,在用我们一开始初始化中设置的属性alternateAddressDelay,就是这个备选连接延时的属性,去延时连接备选地址(当然如果主选地址在此时已经连接成功,会再次连接导致socket错误,并且关闭)。

这两步分别调用了各自的方法去实现,接下来我们先来看创建本机Socket的方法:

本文方法八--创建Socket:

//创建Socket
- (int)createSocket:(int)family connectInterface:(NSData *)connectInterface errPtr:(NSError **)errPtr
{
//创建socket,用的SOCK_STREAM TCP流
int socketFD = socket(family, SOCK_STREAM, 0);
//如果创建失败
if (socketFD == SOCKET_NULL)
{
if (errPtr)
*errPtr = [self errnoErrorWithReason:@"Error in socket() function"];

return socketFD;
}

//和connectInterface绑定
if (![self bindSocket:socketFD toInterface:connectInterface error:errPtr])
{
//绑定失败,直接关闭返回
[self closeSocket:socketFD];

return SOCKET_NULL;
}

// Prevent SIGPIPE signals
//防止终止进程的信号?
int nosigpipe = 1;
//SO_NOSIGPIPE是为了避免网络错误,而导致进程退出。用这个来避免系统发送signal
setsockopt(socketFD, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe, sizeof(nosigpipe));

return socketFD;
}

这个方法做了这么几件事:

  1. 创建了一个socket:

 //创建一个socket,返回值为Int。(注scoket其实就是Int类型)
//第一个参数addressFamily IPv4(AF_INET) 或 IPv6(AF_INET6)。
//第二个参数 type 表示 socket 的类型,通常是流stream(SOCK_STREAM) 或数据报文datagram(SOCK_DGRAM)
//第三个参数 protocol 参数通常设置为0,以便让系统自动为选择我们合适的协议,对于 stream socket 来说会是 TCP 协议(IPPROTO_TCP),而对于 datagram来说会是 UDP 协议(IPPROTO_UDP)。
int socketFD = socket(family, SOCK_STREAM, 0);

其实这个函数在之前那篇IM文章中也讲过了,大家参考参考注释看看就可以了,这里如果返回值为-1,说明创建失败。

  1. 去绑定我们之前创建的本地地址,它调用了另外一个方法来实现。
  2. 最后我们调用了如下函数

   setsockopt(socketFD, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe, sizeof(nosigpipe));

而这里的目的是为了来避免网络错误而出现的进程退出的情况,调用了这行函数,网络错误后,系统不再发送进程退出的信号。
关于这个进程退出的错误可以参考这篇文章:Mac OSX下SO_NOSIGPIPE的怪异表现

未完总结:

connect篇还没有完结,奈何篇幅问题,只能断在这里。下一个方法将是socket本地绑定的方法。再下面就是我们最终的连接方法了,历经九九八十一难,马上就要取到真经了...(然而这仅仅是一个开始...)
下一篇将会承接这一篇的内容继续讲,包括最终连接、连接完成后的source和流的处理。
我们还会去讲讲iOS作为服务端的accpet建立连接的流程。
除此之外还有 unix domin socket(进程间通信)的连接。


CocoaAsyncSocket源码分析---Connect (一)

CocoaAsyncSocket源码分析---Connect (二)

CocoaAsyncSocket源码分析---Connect (三)

CocoaAsyncSocket源码分析---Connect (四)

CocoaAsyncSocket源码分析---Connect (五)

CocoaAsyncSocket源码分析---Connect (六)

CocoaAsyncSocket源码分析---Connect (七)

CocoaAsyncSocket源码分析---Connect (八)


作者:Cooci
链接:https://www.jianshu.com/p/9968ff0280e5

收起阅读 »

CocoaAsyncSocket源码分析---Connect (三)

interface本文方法四--本地地址绑定方法- (void)getInterfaceAddress4:(NSMutableData **)interfaceAddr4Ptr address6:(NSMutableDa...
继续阅读 »

至于有interface,我们所做的额外操作是什么呢,我们接下来看看这个方法:本文方法四--本地地址绑定方法

- (void)getInterfaceAddress4:(NSMutableData **)interfaceAddr4Ptr
address6:(NSMutableData **)interfaceAddr6Ptr
fromDescription:(NSString *)interfaceDescription
port:(uint16_t)port
{
NSMutableData *addr4 = nil;
NSMutableData *addr6 = nil;

NSString *interface = nil;

//先用:分割
NSArray *components = [interfaceDescription componentsSeparatedByString:@":"];
if ([components count] > 0)
{
NSString *temp = [components objectAtIndex:0];
if ([temp length] > 0)
{
interface = temp;
}
}
if ([components count] > 1 && port == 0)
{
//拿到port strtol函数,将一个字符串,根据base参数转成长整型,如base值为10则采用10进制,若base值为16则采用16进制
long portL = strtol([[components objectAtIndex:1] UTF8String], NULL, 10);
//UINT16_MAX,65535最大端口号
if (portL > 0 && portL <= UINT16_MAX)
{
port = (uint16_t)portL;
}
}

//为空则自己创建一个 0x00000000 ,全是0 ,为线路地址
//如果端口为0 通常用于分析操作系统。这一方法能够工作是因为在一些系统中“0”是无效端口,当你试图使用通常的闭合端口连接它时将产生不同的结果。一种典型的扫描,使用IP地址为0.0.0.0,设置ACK位并在以太网层广播。
if (interface == nil)
{

struct sockaddr_in sockaddr4;

//memset作用是在一段内存块中填充某个给定的值,它是对较大的结构体或数组进行清零操作的一种最快方法

//memset(void *s,int ch,size_t n);函数,第一个参数为指针地址,第二个为设置值,第三个为连续设置的长度(大小)
memset(&sockaddr4, 0, sizeof(sockaddr4));
//结构体长度
sockaddr4.sin_len = sizeof(sockaddr4);
//addressFamily IPv4(AF_INET) 或 IPv6(AF_INET6)。
sockaddr4.sin_family = AF_INET;
//端口号 htons将主机字节顺序转换成网络字节顺序 16位
sockaddr4.sin_port = htons(port);
//htonl ,将INADDR_ANY:0.0.0.0,不确定地址,或者任意地址 htonl 32位。 也是转为网络字节序

//ipv4 32位 4个字节 INADDR_ANY,0x00000000 (16进制,一个0代表4位,8个0就是32位) = 4个字节的
sockaddr4.sin_addr.s_addr = htonl(INADDR_ANY);
struct sockaddr_in6 sockaddr6;
memset(&sockaddr6, 0, sizeof(sockaddr6));

sockaddr6.sin6_len = sizeof(sockaddr6);
//ipv6
sockaddr6.sin6_family = AF_INET6;
//port
sockaddr6.sin6_port = htons(port);

//共128位
sockaddr6.sin6_addr = in6addr_any;

//把这两个结构体转成data
addr4 = [NSMutableData dataWithBytes:&sockaddr4 length:sizeof(sockaddr4)];
addr6 = [NSMutableData dataWithBytes:&sockaddr6 length:sizeof(sockaddr6)];
}
//如果localhost、loopback 回环地址,虚拟地址,路由器工作它就存在。一般用来标识路由器
//这两种的话就赋值为127.0.0.1,端口为port
else if ([interface isEqualToString:@"localhost"] || [interface isEqualToString:@"loopback"])
{
// LOOPBACK address

//ipv4
struct sockaddr_in sockaddr4;
memset(&sockaddr4, 0, sizeof(sockaddr4));

sockaddr4.sin_len = sizeof(sockaddr4);
sockaddr4.sin_family = AF_INET;
sockaddr4.sin_port = htons(port);

//#define INADDR_LOOPBACK (u_int32_t)0x7f000001
//7f000001->1111111 00000000 00000000 00000001->127.0.0.1
sockaddr4.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

//ipv6
struct sockaddr_in6 sockaddr6;
memset(&sockaddr6, 0, sizeof(sockaddr6));

sockaddr6.sin6_len = sizeof(sockaddr6);
sockaddr6.sin6_family = AF_INET6;
sockaddr6.sin6_port = htons(port);

sockaddr6.sin6_addr = in6addr_loopback;
//赋值
addr4 = [NSMutableData dataWithBytes:&sockaddr4 length:sizeof(sockaddr4)];
addr6 = [NSMutableData dataWithBytes:&sockaddr6 length:sizeof(sockaddr6)];
}
//非localhost、loopback,去获取本机IP,看和传进来Interface是同名或者同IP,相同才给赋端口号,把数据封装进Data。否则为nil
else
{
//转成cString
const char *iface = [interface UTF8String];

//定义结构体指针,这个指针是本地IP
struct ifaddrs *addrs;
const struct ifaddrs *cursor;

//获取到本机IP,为0说明成功了
if ((getifaddrs(&addrs) == 0))
{
//赋值
cursor = addrs;
//如果IP不为空,则循环链表去设置
while (cursor != NULL)
{
//如果 addr4 IPV4地址为空,而且地址类型为IPV4
if ((addr4 == nil) && (cursor->ifa_addr->sa_family == AF_INET))
{
// IPv4

struct sockaddr_in nativeAddr4;
//memcpy内存copy函数,把src开始到size的字节数copy到 dest中
memcpy(&nativeAddr4, cursor->ifa_addr, sizeof(nativeAddr4));

//比较两个字符串是否相同,本机的IP名,和接口interface是否相同
if (strcmp(cursor->ifa_name, iface) == 0)
{
// Name match
//相同则赋值 port
nativeAddr4.sin_port = htons(port);
//用data封号IPV4地址
addr4 = [NSMutableData dataWithBytes:&nativeAddr4 length:sizeof(nativeAddr4)];
}
//本机IP名和interface不相同
else
{
//声明一个IP 16位的数组
char ip[INET_ADDRSTRLEN];

//这里是转成了10进制。。(因为获取到的是二进制IP)
const char *conversion = inet_ntop(AF_INET, &nativeAddr4.sin_addr, ip, sizeof(ip));

//如果conversion不为空,说明转换成功而且 ,比较转换后的IP,和interface是否相同
if ((conversion != NULL) && (strcmp(ip, iface) == 0))
{
// IP match
//相同则赋值 port
nativeAddr4.sin_port = htons(port);

addr4 = [NSMutableData dataWithBytes:&nativeAddr4 length:sizeof(nativeAddr4)];
}
}
}
//IPV6 一样
else if ((addr6 == nil) && (cursor->ifa_addr->sa_family == AF_INET6))
{
// IPv6

struct sockaddr_in6 nativeAddr6;
memcpy(&nativeAddr6, cursor->ifa_addr, sizeof(nativeAddr6));

if (strcmp(cursor->ifa_name, iface) == 0)
{
// Name match

nativeAddr6.sin6_port = htons(port);

addr6 = [NSMutableData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)];
}
else
{
char ip[INET6_ADDRSTRLEN];

const char *conversion = inet_ntop(AF_INET6, &nativeAddr6.sin6_addr, ip, sizeof(ip));

if ((conversion != NULL) && (strcmp(ip, iface) == 0))
{
// IP match

nativeAddr6.sin6_port = htons(port);

addr6 = [NSMutableData dataWithBytes:&nativeAddr6 length:sizeof(nativeAddr6)];
}
}
}

//指向链表下一个addr
cursor = cursor->ifa_next;
}
//和getifaddrs对应,释放这部分内存
freeifaddrs(addrs);
}
}
//如果这两个二级指针存在,则取成一级指针,把addr4赋值给它
if (interfaceAddr4Ptr) *interfaceAddr4Ptr = addr4;
if (interfaceAddr6Ptr) *interfaceAddr6Ptr = addr6;

这个方法中,主要是大量的socket相关的函数的调用,会显得比较难读一点,其实简单来讲就做了这么一件事:
interface变成进行socket操作所需要的地址结构体,然后把地址结构体包裹在NSMutableData中。

这里,为了让大家能更容易理解,我把这个方法涉及到的socket相关函数以及宏(按照调用顺序)都列出来:


//拿到port strtol函数,将一个字符串,根据base参数转成长整型,
//如base值为10则采用10进制,若base值为16则采用16进制
long strtol(const char *__str, char **__endptr, int __base);

//作用是在一段内存块中填充某个给定的值,它是对较大的结构体或数组进行清零操作的一种最快方法
//第一个参数为指针地址,第二个为设置值,第三个为连续设置的长度(大小)
memset(void *s,int ch,size_t n);

//最大端口号
#define UINT16_MAX 65535

//作用是把主机字节序转化为网络字节序
htons() //参数16位
htonl() //参数32位
//获取占用内存大小
sizeof()
//比较两个指针,是否相同 相同返回0
int strcmp(const char *__s1, const char *__s2)

//内存copu函数,把src开始到len的字节数copy到 dest中
memcpy(dest, src, len)

//inet_pton和inet_ntop这2个IP地址转换函数,可以在将IP地址在“点分十进制”和“二进制整数”之间转换
//参数socklen_t cnt,他是所指向缓存区dst的大小,避免溢出,如果缓存区太小无法存储地址的值,则返回一个空指针,并将errno置为ENOSPC
const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt);

//得到本机地址
extern int getifaddrs(struct ifaddrs **);
//释放本机地址
extern void freeifaddrs(struct ifaddrs *);
还有一些用到的作为参数的结构体:

//socket通信用的 IPV4地址结构体 
struct sockaddr_in {
__uint8_t sin_len; //整个结构体大小
sa_family_t sin_family; //协议族,IPV4?IPV6
in_port_t sin_port; //端口
struct in_addr sin_addr; //IP地址
char sin_zero[8]; //空的占位符,为了和其他地址结构体保持一致大小,方便转化
};
//IPV6地址结构体,和上面的类似
struct sockaddr_in6 {
__uint8_t sin6_len; /* length of this struct(sa_family_t) */
sa_family_t sin6_family; /* AF_INET6 (sa_family_t) */
in_port_t sin6_port; /* Transport layer port # (in_port_t) */
__uint32_t sin6_flowinfo; /* IP6 flow information */
struct in6_addr sin6_addr; /* IP6 address */
__uint32_t sin6_scope_id; /* scope zone index */
};

//用来获取本机IP的参数结构体
struct ifaddrs {
//指向链表的下一个成员
struct ifaddrs *ifa_next;
//接口名称
char *ifa_name;
//接口标识位(比如当IFF_BROADCAST或IFF_POINTOPOINT设置到此标识位时,影响联合体变量ifu_broadaddr存储广播地址或ifu_dstaddr记录点对点地址)
unsigned int ifa_flags;
//接口地址
struct sockaddr *ifa_addr;
//存储该接口的子网掩码;
struct sockaddr *ifa_netmask;

//点对点的地址
struct sockaddr *ifa_dstaddr;
//ifa_data存储了该接口协议族的特殊信息,它通常是NULL(一般不关注他)。
void *ifa_data;
};


这一段内容算是比较枯涩了,但是也是了解socket编程必经之路。

这里提到了网络字节序和主机字节序。我们创建socket之前,必须把port和host这些参数转化为网络字节序。那么为什么要这么做呢?

不同的CPU有不同的字节序类型 这些字节序是指整数在内存中保存的顺序 这个叫做主机序
最常见的有两种
1. Little endian:将低序字节存储在起始地址
2. Big endian:将高序字节存储在起始地址

这样如果我们到网络中,就无法得知互相的字节序是什么了,所以我们就必须统一一套排序,这样网络字节序就有它存在的必要了。


网络字节顺序是TCP/IP中规定好的一种数据表示格式,它与具体的CPU类型、操作系统等无关。从而可以保证数据在不同主机之间传输时能够被正确解释。网络字节顺序采用big endian排序方式。

除此之外比较重要的就是这几个地址结构体了。它定义了我们当前socket的地址信息。包括IP、Port、长度、协议族等等。当然socket中标识为地址的结构体不止这3种,等我们后续代码来补充。


大家了解了我们上述说的知识点,这个方法也就不难度了。这个方法主要是做了本机IPV4IPV6地址的创建和绑定。当然这里分了几种情况:

  1. interface为空的,我们作为客户端不会出现这种情况。注意之前我们是这个参数不为空才会调入这个方法的。
    而这个一般是用于做服务端监听用的,这里的处理是给本机地址绑定0地址(任意地址)。那么这里这么做作用是什么呢?引用一个应用场景来说明:

如果你的服务器有多个网卡(每个网卡上有不同的IP地址),而你的服务(不管是在udp端口上侦听,还是在tcp端口上侦听),出于某种原因:可能是你的服务器操作系统可能随时增减IP地址,也有可能是为了省去确定服务器上有什么网络端口(网卡)的麻烦 —— 可以要在调用bind()的时候,告诉操作系统:“我需要在 yyyy 端口上侦听,所有发送到服务器的这个端口,不管是哪个网卡/哪个IP地址接收到的数据,都是我处理的。”这时候,服务器程序则在0.0.0.0这个地址上进行侦听。

  1. 如果interfacelocalhost或者loopback则把IP设置为127.0.0.1,这里localhost我们大家都知道。那么什么是loopback呢?
    loopback地址叫做回环地址,他不是一个物理接口上的地址,他是一个虚拟的一个地址,只要路由器在工作,这个地址就存在.它是路由器的唯一标识。
    更详细的内容可以看看百科:loopback

  2. 如果是一个其他的地址,我们会去使用getifaddrs()函数得到本机地址。然后去对比本机名或者本机IP。有一个能相同,我们就认为该地址有效,就进行IPV4和IPV6绑定。否则什么都不做。

至此这个本机地址绑定我们就做完了,我们前面也说过,一般我们作为客户端,是不需要做这一步的。如果我们不绑定,系统会自己绑定本机IP,并且选择一个空闲可用的端口。所以这个方法是iOS用来作为服务端调用的。


方法三--前置检查、方法四--本机地址绑定都说完了,我们继续接着之前的方法二往下看:

之前讲到第3点了:
3.这里把flag标记为kSocketStarted:

flags |= kSocketStarted;

源码中大量的运用了3个位运算符:分别是或(|)、与(&)、取反(~)、运算符。 运用这个标记的好处也很明显,可以很简单的标记当前的状态,并且因为flags所指向的枚举值是用左位移的方式:

enum GCDAsyncSocketFlags
{
kSocketStarted = 1 << 0, // If set, socket has been started (accepting/connecting)
kConnected = 1 << 1, // If set, the socket is connected
kForbidReadsWrites = 1 << 2, // If set, no new reads or writes are allowed
kReadsPaused = 1 << 3, // If set, reads are paused due to possible timeout
kWritesPaused = 1 << 4, // If set, writes are paused due to possible timeout
kDisconnectAfterReads = 1 << 5, // If set, disconnect after no more reads are queued
kDisconnectAfterWrites = 1 << 6, // If set, disconnect after no more writes are queued
kSocketCanAcceptBytes = 1 << 7, // If set, we know socket can accept bytes. If unset, it's unknown.
kReadSourceSuspended = 1 << 8, // If set, the read source is suspended
kWriteSourceSuspended = 1 << 9, // If set, the write source is suspended
kQueuedTLS = 1 << 10, // If set, we've queued an upgrade to TLS
kStartingReadTLS = 1 << 11, // If set, we're waiting for TLS negotiation to complete
kStartingWriteTLS = 1 << 12, // If set, we're waiting for TLS negotiation to complete
kSocketSecure = 1 << 13, // If set, socket is using secure communication via SSL/TLS
kSocketHasReadEOF = 1 << 14, // If set, we have read EOF from socket
kReadStreamClosed = 1 << 15, // If set, we've read EOF plus prebuffer has been drained
kDealloc = 1 << 16, // If set, the socket is being deallocated
#if TARGET_OS_IPHONE
kAddedStreamsToRunLoop = 1 << 17, // If set, CFStreams have been added to listener thread
kUsingCFStreamForTLS = 1 << 18, // If set, we're forced to use CFStream instead of SecureTransport
kSecureSocketHasBytesAvailable = 1 << 19, // If set, CFReadStream has notified us of bytes available
#endif
};


所以flags可以通过|的方式复合横跨多个状态,并且运算也非常轻量级,好处很多,所有的状态标记的意义可以在注释中清晰的看出,这里把状态标记为socket已经开始连接了。

4.然后我们调用了一个全局queue,异步的调用连接,这里又做了两件事:

  • 第一步是拿到我们需要连接的服务端server的地址数组:

//server地址数组(包含IPV4 IPV6的地址  sockaddr_in6、sockaddr_in类型)
NSMutableArray *addresses = [[self class] lookupHost:hostCpy port:port error:&lookupErr];





收起阅读 »

CocoaAsyncSocket源码分析---Connect (二)

connect也就是我们在截图中选中的方法,那我们就从这个方法作为起点,开始讲起吧。保证这个连接操作一定是在我们的接着把Block中连接过程产生的错误进行赋值,并且把连接的结果返回出去//如果有错误,赋值错误 if (errPtr) *errPtr =...
继续阅读 »

这里我们先作为客户端来看看connect



其中和connect相关的方法就这么多,我们一般这么来连接到服务端:

[socket connectToHost:Khost onPort:Kport error:nil];


也就是我们在截图中选中的方法,那我们就从这个方法作为起点,开始讲起吧。

本文方法二--connect总方法
/逐级调用
- (BOOL)connectToHost:(NSString*)host onPort:(uint16_t)port error:(NSError **)errPtr
{
return [self connectToHost:host onPort:port withTimeout:-1 error:errPtr];
}

- (BOOL)connectToHost:(NSString *)host
onPort:(uint16_t)port
withTimeout:(NSTimeInterval)timeout
error:(NSError **)errPtr
{
return [self connectToHost:host onPort:port viaInterface:nil withTimeout:timeout error:errPtr];
}

//多一个inInterface,本机地址
- (BOOL)connectToHost:(NSString *)inHost
onPort:(uint16_t)port
viaInterface:(NSString *)inInterface
withTimeout:(NSTimeInterval)timeout
error:(NSError **)errPtr
{
//{} 跟踪当前行为
LogTrace();

// Just in case immutable objects were passed
//拿到host ,copy防止值被修改
NSString *host = [inHost copy];
//interface?接口?
NSString *interface = [inInterface copy];

//声明两个__block的
__block BOOL result = NO;
//error信息
__block NSError *preConnectErr = nil;

//gcdBlock ,都包裹在自动释放池中
dispatch_block_t block = ^{ @autoreleasepool {

// Check for problems with host parameter

if ([host length] == 0)
{
NSString *msg = @"Invalid host parameter (nil or \"\"). Should be a domain name or IP address string.";
preConnectErr = [self badParamError:msg];

//其实就是return,大牛的代码真是充满逼格
return_from_block;
}

// Run through standard pre-connect checks
//一个前置的检查,如果没通过返回,这个检查里,如果interface有值,则会将本机的IPV4 IPV6的 address设置上。
if (![self preConnectWithInterface:interface error:&preConnectErr])
{
return_from_block;
}

// We've made it past all the checks.
// It's time to start the connection process.
//flags 做或等运算。 flags标识为开始Socket连接
flags |= kSocketStarted;

//又是一个{}? 只是为了标记么?
LogVerbose(@"Dispatching DNS lookup...");

// It's possible that the given host parameter is actually a NSMutableString.
//很可能给我们的服务端的参数是一个可变字符串
// So we want to copy it now, within this block that will be executed synchronously.
//所以我们需要copy,在Block里同步的执行
// This way the asynchronous lookup block below doesn't have to worry about it changing.
//这种基于Block的异步查找,不需要担心它被改变

//copy,防止改变
NSString *hostCpy = [host copy];

//拿到状态
int aStateIndex = stateIndex;
__weak GCDAsyncSocket *weakSelf = self;

//全局Queue
dispatch_queue_t globalConcurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//异步执行
dispatch_async(globalConcurrentQueue, ^{ @autoreleasepool {
//忽视循环引用
#pragma clang diagnostic push
#pragma clang diagnostic warning "-Wimplicit-retain-self"

//查找错误
NSError *lookupErr = nil;
//server地址数组(包含IPV4 IPV6的地址 sockaddr_in6、sockaddr_in类型)
NSMutableArray *addresses = [[self class] lookupHost:hostCpy port:port error:&lookupErr];

//strongSelf
__strong GCDAsyncSocket *strongSelf = weakSelf;

//完整Block安全形态,在加个if
if (strongSelf == nil) return_from_block;

//如果有错
if (lookupErr)
{
//用cocketQueue
dispatch_async(strongSelf->socketQueue, ^{ @autoreleasepool {
//一些错误处理,清空一些数据等等
[strongSelf lookup:aStateIndex didFail:lookupErr];
}});
}
//正常
else
{

NSData *address4 = nil;
NSData *address6 = nil;
//遍历地址数组
for (NSData *address in addresses)
{
//判断address4为空,且address为IPV4
if (!address4 && [[self class] isIPv4Address:address])
{
address4 = address;
}
//判断address6为空,且address为IPV6
else if (!address6 && [[self class] isIPv6Address:address])
{
address6 = address;
}
}
//异步去发起连接
dispatch_async(strongSelf->socketQueue, ^{ @autoreleasepool {

[strongSelf lookup:aStateIndex didSucceedWithAddress4:address4 address6:address6];
}});
}

#pragma clang diagnostic pop
}});

//开启连接超时
[self startConnectTimeout:timeout];

result = YES;
}};
//在socketQueue中执行这个Block
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
//否则同步的调起这个queue去执行
else
dispatch_sync(socketQueue, block);

//如果有错误,赋值错误
if (errPtr) *errPtr = preConnectErr;
//把连接是否成功的result返回
return result;
}

这个方法非常长,它主要做了以下几件事:

  • 首先我们需要说一下的是,整个类大量的会出现LogTrace()类似这样的宏,我们点进去发现它的本质只是一个{},什么事都没做。

原来这些宏是为了追踪当前执行的流程用的,它被定义在一个大的#if #else中:

#ifndef GCDAsyncSocketLoggingEnabled
#define GCDAsyncSocketLoggingEnabled 0
#endif
#if GCDAsyncSocketLoggingEnabled
// Logging Enabled - See log level below
// Logging uses the CocoaLumberjack framework (which is also GCD based).
// https://github.com/robbiehanson/CocoaLumberjack
//
// It allows us to do a lot of logging without significantly slowing down the code.
#import "DDLog.h"
#define LogAsync YES
#define LogContext GCDAsyncSocketLoggingContext
#define LogObjc(flg, frmt, ...) LOG_OBJC_MAYBE(LogAsync, logLevel, flg, LogContext, frmt, ##__VA_ARGS__)
#define LogC(flg, frmt, ...) LOG_C_MAYBE(LogAsync, logLevel, flg, LogContext, frmt, ##__VA_ARGS__)
#define LogError(frmt, ...) LogObjc(LOG_FLAG_ERROR, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogWarn(frmt, ...) LogObjc(LOG_FLAG_WARN, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogInfo(frmt, ...) LogObjc(LOG_FLAG_INFO, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogVerbose(frmt, ...) LogObjc(LOG_FLAG_VERBOSE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogCError(frmt, ...) LogC(LOG_FLAG_ERROR, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogCWarn(frmt, ...) LogC(LOG_FLAG_WARN, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogCInfo(frmt, ...) LogC(LOG_FLAG_INFO, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogCVerbose(frmt, ...) LogC(LOG_FLAG_VERBOSE, (@"%@: " frmt), THIS_FILE, ##__VA_ARGS__)
#define LogTrace() LogObjc(LOG_FLAG_VERBOSE, @"%@: %@", THIS_FILE, THIS_METHOD)
#define LogCTrace() LogC(LOG_FLAG_VERBOSE, @"%@: %s", THIS_FILE, __FUNCTION__)
#ifndef GCDAsyncSocketLogLevel
#define GCDAsyncSocketLogLevel LOG_LEVEL_VERBOSE
#endif
// Log levels : off, error, warn, info, verbose
static const int logLevel = GCDAsyncSocketLogLevel;
#else
// Logging Disabled
#define LogError(frmt, ...) {}
#define LogWarn(frmt, ...) {}
#define LogInfo(frmt, ...) {}
#define LogVerbose(frmt, ...) {}
#define LogCError(frmt, ...) {}
#define LogCWarn(frmt, ...) {}
#define LogCInfo(frmt, ...) {}
#define LogCVerbose(frmt, ...) {}
#define LogTrace() {}
#define LogCTrace(frmt, ...) {}
#endif


而此时因为GCDAsyncSocketLoggingEnabled默认为0,所以仅仅是一个{}。当标记为1时,这些宏就可以用来输出我们当前的业务流程,极大的方便了我们的调试过程。

  • 接着我们回到正题上,我们定义了一个Block,所有的连接操作都被包裹在这个Block中。我们做了如下判断:

    //在socketQueue中执行这个Block
if (dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey))
block();
//否则同步的调起这个queue去执行
else
dispatch_sync(socketQueue, block);

保证这个连接操作一定是在我们的socketQueue中,而且还是以串行同步的形式去执行,规避了线程安全的问题。

  • 接着把Block中连接过程产生的错误进行赋值,并且把连接的结果返回出去
//如果有错误,赋值错误
if (errPtr) *errPtr = preConnectErr;
//把连接是否成功的result返回
return result;

接着来看这个方法声明的Block内部,也就是进行连接的真正主题操作,这个连接过程将会调用许多函数,一环扣一环,我会尽可能用最清晰、详尽的语言来描述...

1.这个Block首先做了一些错误的判断,并调用了一些错误生成的方法。类似:

if ([host length] == 0)
{
NSString *msg = @"Invalid host parameter (nil or \"\"). Should be a domain name or IP address string.";
preConnectErr = [self badParamError:msg];

//其实就是return,大牛的代码真是充满逼格
return_from_block;
}
//用该字符串生成一个错误,错误的域名,错误的参数
- (NSError *)badParamError:(NSString *)errMsg
{
NSDictionary *userInfo = [NSDictionary dictionaryWithObject:errMsg forKey:NSLocalizedDescriptionKey];

return [NSError errorWithDomain:GCDAsyncSocketErrorDomain code:GCDAsyncSocketBadParamError userInfo:userInfo];
}

2.接着做了一个前置的错误检查:
if (![self preConnectWithInterface:interface error:&preConnectErr])
{
return_from_block;
}
这个检查方法,如果没通过返回NO。并且如果interface有值,则会将本机的IPV4 IPV6的 address设置上。即我们之前提到的这两个属性:
  //本机的IPV4地址
NSData * connectInterface4;
//本机的IPV6地址
NSData * connectInterface6;

我们来看看这个前置检查方法:

本文方法三--前置检查方法
//在连接之前的接口检查,一般我们传nil  interface本机的IP 端口等等
- (BOOL)preConnectWithInterface:(NSString *)interface error:(NSError **)errPtr
{
//先断言,如果当前的queue不是初始化quueue,直接报错
NSAssert(dispatch_get_specific(IsOnSocketQueueOrTargetQueueKey), @"Must be dispatched on socketQueue");

//无代理
if (delegate == nil) // Must have delegate set
{
if (errPtr)
{
NSString *msg = @"Attempting to connect without a delegate. Set a delegate first.";
*errPtr = [self badConfigError:msg];
}
return NO;
}
//没有代理queue
if (delegateQueue == NULL) // Must have delegate queue set
{
if (errPtr)
{
NSString *msg = @"Attempting to connect without a delegate queue. Set a delegate queue first.";
*errPtr = [self badConfigError:msg];
}
return NO;
}

//当前不是非连接状态
if (![self isDisconnected]) // Must be disconnected
{
if (errPtr)
{
NSString *msg = @"Attempting to connect while connected or accepting connections. Disconnect first.";
*errPtr = [self badConfigError:msg];
}
return NO;
}

//判断是否支持IPV4 IPV6 &位与运算,因为枚举是用 左位移<<运算定义的,所以可以用来判断 config包不包含某个枚举。因为一个值可能包含好几个枚举值,所以这时候不能用==来判断,只能用&来判断
BOOL isIPv4Disabled = (config & kIPv4Disabled) ? YES : NO;
BOOL isIPv6Disabled = (config & kIPv6Disabled) ? YES : NO;

//是否都不支持
if (isIPv4Disabled && isIPv6Disabled) // Must have IPv4 or IPv6 enabled
{
if (errPtr)
{
NSString *msg = @"Both IPv4 and IPv6 have been disabled. Must enable at least one protocol first.";
*errPtr = [self badConfigError:msg];
}
return NO;
}

//如果有interface,本机地址
if (interface)
{
NSMutableData *interface4 = nil;
NSMutableData *interface6 = nil;

//得到本机的IPV4 IPV6地址
[self getInterfaceAddress4:&interface4 address6:&interface6 fromDescription:interface port:0];

//如果两者都为nil
if ((interface4 == nil) && (interface6 == nil))
{
if (errPtr)
{
NSString *msg = @"Unknown interface. Specify valid interface by name (e.g. \"en1\") or IP address.";
*errPtr = [self badParamError:msg];
}
return NO;
}

if (isIPv4Disabled && (interface6 == nil))
{
if (errPtr)
{
NSString *msg = @"IPv4 has been disabled and specified interface doesn't support IPv6.";
*errPtr = [self badParamError:msg];
}
return NO;
}

if (isIPv6Disabled && (interface4 == nil))
{
if (errPtr)
{
NSString *msg = @"IPv6 has been disabled and specified interface doesn't support IPv4.";
*errPtr = [self badParamError:msg];
}
return NO;
}
//如果都没问题,则赋值
connectInterface4 = interface4;
connectInterface6 = interface6;
}

// Clear queues (spurious read/write requests post disconnect)
//清除queue(假的读写请求 ,提交断开连接)
//读写Queue清除
[readQueue removeAllObjects];
[writeQueue removeAllObjects];

return YES;
}

又是非常长的一个方法,但是这个方法还是非常好读的。

  • 主要是对连接前的一个属性参数的判断,如果不齐全的话,则填充错误指针,并且返回NO。

  • 在这里如果我们interface这个参数不为空话,我们会额外多执行一些操作。
    首先来讲讲这个参数是什么,简单来讲,这个就是我们设置的本机IP+端口号。照理来说我们是不需要去设置这个参数的,默认的为localhost(127.0.0.1)本机地址。而端口号会在本机中取一个空闲可用的端口。
    而我们一旦设置了这个参数,就会强制本地IP和端口为我们指定的。其实这样设置反而不好,其实大家也能想明白,这里端口号如果我们写死,万一被其他进程给占用了。那么肯定是无法连接成功的。
    所以就有了我们做IM的时候,一般是不会去指定客户端bind某一个端口。而是用系统自动去选择。

  • 我们最后清空了当前读写queue中,所有的任务。

至于有interface,我们所做的额外操作是什么呢,我们接下来看下一章






作者:Cooci
链接:https://www.jianshu.com/p/9968ff0280e5






收起阅读 »

CocoaAsyncSocket源码分析---Connect (一)

CocoaAsyncSocket是谷歌的开发者,基于BSD-Socket写的一个IM框架,它给Mac和iOS提供了易于使用的、强大的异步套接字库,向上封装出简单易用OC接口。省去了我们面向Socket以及数据流Stream等繁琐复杂的编程。本文为一个系列,旨在...
继续阅读 »
CocoaAsyncSocket是谷歌的开发者,基于BSD-Socket写的一个IM框架,它给Mac和iOS提供了易于使用的、强大的异步套接字库,向上封装出简单易用OC接口。省去了我们面向Socket以及数据流Stream等繁琐复杂的编程。
本文为一个系列,旨在让大家了解CocoaAsyncSocket是如何基于底层进行封装、工作的。

附上一张socket流程图



正文:
首先我们来看看框架:

整个库就这么两个类,一个基于TCP,一个基于UDP。其中基于TCP的GCDAsyncSocket,大概8000多行代码。而GCDAsyncUdpSocket稍微少一点,也有5000多行。
所以单纯从代码量上来看,这个库还是做了很多事的。

顺便提一下,之前这个框架还有一个runloop版的,不过因为功能重叠和其它种种原因,后续版本便废弃了,现在仅有GCD版本。

本系列我们将重点来讲GCDAsyncSocket这个类。

我们先来看看这个类的属性:

@implementation GCDAsyncSocket
{
//flags,当前正在做操作的标识符
uint32_t flags;
uint16_t config;

//代理
__weak id<GCDAsyncSocketDelegate> delegate;
//代理回调的queue
dispatch_queue_t delegateQueue;

//本地IPV4Socket
int socket4FD;
//本地IPV6Socket
int socket6FD;
//unix域的套接字
int socketUN;
//unix域 服务端 url
NSURL *socketUrl;
//状态Index
int stateIndex;

//本机的IPV4地址
NSData * connectInterface4;
//本机的IPV6地址
NSData * connectInterface6;
//本机unix域地址
NSData * connectInterfaceUN;

//这个类的对Socket的操作都在这个queue中,串行
dispatch_queue_t socketQueue;

dispatch_source_t accept4Source;
dispatch_source_t accept6Source;
dispatch_source_t acceptUNSource;

//连接timer,GCD定时器
dispatch_source_t connectTimer;
dispatch_source_t readSource;
dispatch_source_t writeSource;
dispatch_source_t readTimer;
dispatch_source_t writeTimer;

//读写数据包数组 类似queue,最大限制为5个包
NSMutableArray *readQueue;
NSMutableArray *writeQueue;

//当前正在读写数据包
GCDAsyncReadPacket *currentRead;
GCDAsyncWritePacket *currentWrite;
//当前socket未获取完的数据大小
unsigned long socketFDBytesAvailable;

//全局公用的提前缓冲区
GCDAsyncSocketPreBuffer *preBuffer;

#if TARGET_OS_IPHONE
CFStreamClientContext streamContext;
//读的数据流
CFReadStreamRef readStream;
//写的数据流
CFWriteStreamRef writeStream;
#endif
//SSL上下文,用来做SSL认证
SSLContextRef sslContext;

//全局公用的SSL的提前缓冲区
GCDAsyncSocketPreBuffer *sslPreBuffer;
size_t sslWriteCachedLength;

//记录SSL读取数据错误
OSStatus sslErrCode;
//记录SSL握手的错误
OSStatus lastSSLHandshakeError;

//socket队列的标识key
void *IsOnSocketQueueOrTargetQueueKey;

id userData;

//连接备选服务端地址的延时 (另一个IPV4或IPV6)
NSTimeInterval alternateAddressDelay;
}

这个里定义了一些属性,可以先简单看看注释,这里我们仅仅先暂时列出来,给大家混个眼熟。
在接下来的代码中,会大量穿插着这些属性的使用。所以大家不用觉得困惑,具体作用,我们后面会一一讲清楚的。

接着我们来看看本文方法一--初始化方法:
//层级调用
- (id)init
{
return [self initWithDelegate:nil delegateQueue:NULL socketQueue:NULL];
}

- (id)initWithSocketQueue:(dispatch_queue_t)sq
{
return [self initWithDelegate:nil delegateQueue:NULL socketQueue:sq];
}

- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq
{
return [self initWithDelegate:aDelegate delegateQueue:dq socketQueue:NULL];
}

- (id)initWithDelegate:(id)aDelegate delegateQueue:(dispatch_queue_t)dq socketQueue:(dispatch_queue_t)sq
{
if((self = [super init]))
{
delegate = aDelegate;
delegateQueue = dq;

//这个宏是在sdk6.0之后才有的,如果是之前的,则OS_OBJECT_USE_OBJC为0,!0即执行if语句
//对6.0的适配,如果是6.0以下,则去retain release,6.0之后ARC也管理了GCD
#if !OS_OBJECT_USE_OBJC

if (dq) dispatch_retain(dq);
#endif

//创建socket,先都置为 -1
//本机的ipv4
socket4FD = SOCKET_NULL;
//ipv6
socket6FD = SOCKET_NULL;
//应该是UnixSocket
socketUN = SOCKET_NULL;
//url
socketUrl = nil;
//状态
stateIndex = 0;

if (sq)
{
//如果scoketQueue是global的,则报错。断言必须要一个非并行queue。
NSAssert(sq != dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0),
@"The given socketQueue parameter must not be a concurrent queue.");
NSAssert(sq != dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0),
@"The given socketQueue parameter must not be a concurrent queue.");
NSAssert(sq != dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0),
@"The given socketQueue parameter must not be a concurrent queue.");
//拿到scoketQueue
socketQueue = sq;
//iOS6之下retain
#if !OS_OBJECT_USE_OBJC
dispatch_retain(sq);
#endif
}
else
{
//没有的话创建一个, 名字为:GCDAsyncSocket,串行
socketQueue = dispatch_queue_create([GCDAsyncSocketQueueName UTF8String], NULL);
}

// The dispatch_queue_set_specific() and dispatch_get_specific() functions take a "void *key" parameter.
// From the documentation:
//
// > Keys are only compared as pointers and are never dereferenced.
// > Thus, you can use a pointer to a static variable for a specific subsystem or
// > any other value that allows you to identify the value uniquely.
//
// We're just going to use the memory address of an ivar.
// Specifically an ivar that is explicitly named for our purpose to make the code more readable.
//
// However, it feels tedious (and less readable) to include the "&" all the time:
// dispatch_get_specific(&IsOnSocketQueueOrTargetQueueKey)
//
// So we're going to make it so it doesn't matter if we use the '&' or not,
// by assigning the value of the ivar to the address of the ivar.
// Thus: IsOnSocketQueueOrTargetQueueKey == &IsOnSocketQueueOrTargetQueueKey;

//比如原来为 0X123 -> NULL 变成 0X222->0X123->NULL
//自己的指针等于自己原来的指针,成二级指针了 看了注释是为了以后省略&,让代码更可读?
IsOnSocketQueueOrTargetQueueKey = &IsOnSocketQueueOrTargetQueueKey;

void *nonNullUnusedPointer = (__bridge void *)self;

//dispatch_queue_set_specific给当前队里加一个标识 dispatch_get_specific当前线程取出这个标识,判断是不是在这个队列
//这个key的值其实就是一个一级指针的地址 ,第三个参数把自己传过去了,上下文对象?第4个参数,为销毁的时候用的,可以指定一个函数
dispatch_queue_set_specific(socketQueue, IsOnSocketQueueOrTargetQueueKey, nonNullUnusedPointer, NULL);
//读的数组 限制为5
readQueue = [[NSMutableArray alloc] initWithCapacity:5];
currentRead = nil;

//写的数组,限制5
writeQueue = [[NSMutableArray alloc] initWithCapacity:5];
currentWrite = nil;

//设置大小为 4kb
preBuffer = [[GCDAsyncSocketPreBuffer alloc] initWithCapacity:(1024 * 4)];

#pragma mark alternateAddressDelay??
//交替地址延时?? wtf
alternateAddressDelay = 0.3;
}
return self;
}


其中值得一提的是第三种:UnixSocket,这个是用于Unix Domin Socket通信用的。
那么什么是Unix Domain Socket呢?
原来它是在socket的框架上发展出一种IPC(进程间通信)机制,虽然网络socket也可用于同一台主机的进程间通讯(通过loopback地址127.0.0.1),但是UNIX Domain Socket用于IPC 更有效率 :

  • 不需要经过网络协议栈
  • 不需要打包拆包、计算校验和、维护序号和应答等,只是将应用层数据从一个进程拷贝到另一个进程。这是因为,IPC机制本质上是可靠的通讯,而网络协议是为不可靠的通讯设计的。UNIX Domain Socket也提供面向流和面向数据包两种API接口,类似于TCP和UDP,但是面向消息的UNIX Domain Socket也是可靠的,消息既不会丢失也不会顺序错乱。

基本上它是当今应用于IPC最主流的方式。至于它到底和普通的socket通信实现起来有什么区别,别着急,我们接着往下看。

3.生成了一个socketQueue,这个queue是串行的,接下来我们看代码就会知道它贯穿于这个类的所有地方。所有对socket以及一些内部数据的相关操作,都需要在这个串行queue中进行。这样使得整个类没有加一个锁,就保证了整个类的线程安全。

4.创建了两个读写队列(本质数组),接下来我们所有的读写任务,都会先追加在这个队列最后,然后每次取出队列中最前面的任务,进行处理。

5.创建了一个全局的数据缓冲区:preBuffer,我们所操作的数据,大部分都是要先存入这个preBuffer中,然后再从preBuffer取出进行处理的。

6.初始化了一个交替延时变量:alternateAddressDelay,这个变量先简单的理解下:就是进行另一个服务端地址请求的延时。后面我们一讲到,大家就明白了。

初始化方法就到此为止了。

接着我们有socket了,我们如果是客户端,就需要去connect服务器。

又或者我们是服务端的话,就需要去bind端口,并且accept,等待客户端的连接。(基本上也没有用iOS来做服务端的吧...)

connect总方法见下篇


全篇地址

CocoaAsyncSocket源码分析---Connect (一)

CocoaAsyncSocket源码分析---Connect (二)

CocoaAsyncSocket源码分析---Connect (三)

CocoaAsyncSocket源码分析---Connect (四)

CocoaAsyncSocket源码分析---Connect (五)

CocoaAsyncSocket源码分析---Connect (六)

CocoaAsyncSocket源码分析---Connect (七)


作者:Cooci

链接:https://www.jianshu.com/p/9968ff0280e5







收起阅读 »

汉字笔顺动画技术剖析

背景 汉字笔顺动画是常见的语文教育需求,我们导入网上开源的 Hanzi Writter 并部署编辑器,应用在大力智能作业灯上。在原版前端实现基础上我们扩展了 Android 和 iOS 端实现,提供更优化的笔顺动画性能。增强对笔顺绘制的控制能力,实现了指定笔...
继续阅读 »

背景


汉字笔顺动画是常见的语文教育需求,我们导入网上开源的 Hanzi Writter 并部署编辑器,应用在大力智能作业灯上。在原版前端实现基础上我们扩展了 Android 和 iOS 端实现,提供更优化的笔顺动画性能。增强对笔顺绘制的控制能力,实现了指定笔顺/笔段渲染,支持笔顺批改和描红能力。



关键技术


1. 字形数据提取


字形是单个字符的外观形状,而字体是具有相同外观样式和排版尺寸的字形集合。基于字形数据,我们可以实现每个文字的渲染和笔顺动画。那么该如何拿到字形数据呢?TTF就是不错的选择。TTF(TrueTypeFont)是一种曲线描边字体文件格式,由Apple公司和Microsoft公司共同推出,其文件扩展名为.ttf。它支持多种字体,如语文课本中常见的楷体。TTF文件由一系列表组成,其中glyf表就包括了字形数据,即字形的轮廓定义和调整指令。依据下述流程可以提取字形数据:



  1. 对不同字体的boundary进行适配,全部转换成1024*1024,并对上下左右进行微调。

  2. 提取所有字形glyph的轮廓点contours和path数据。



提取出字形数据后,使用SVG将对应文字绘制出来。



2. Stroke Extraction 笔画拆取


在第一节中实现了字形数据的提取,它包括字形的轮廓点contours及path(a)。但是仅依靠这些数据无法实现笔顺动画,因为它们只有轮廓信息,没有笔画信息,只要有交叉重叠,都会识别成同一个体(b)。因此,要实现笔顺动画,就必须从源数据中拆取出所有笔画的轮廓数据,即笔画拆取。



2.1 解决思路


由于笔画之间存在交叉重叠(c),若要实现笔画拆取,就需要将笔画交接处的凹点连通起来。这些处于交叉处特殊的拐角点称为corner,连通两个corner形成bridge,表明他们同属于一个笔画。


当顺时针跟踪端点:



  • 连通前:依据轮廓点顺序。


  • 连通后:会依据bridge直接联通对应corner,从而实现笔画的拆分。




因此,笔画拆取工作主要分为以下四步:



2.2 EndPoint Parsing Corner检测


在Hanzi Writter开源库中,笔画拆取算法主要围绕corner展开。那corner是什么呢?详细来说,corner是位于两个笔画轮廓交界的特殊端点,通常情况下,他会有另一个corner与之匹配,如C1和C2。C1和C2相邻且处于笔画A的轮廓同侧,连通C1和C2就可以将笔画A和笔画B拆分开来,得到笔画A自己的轮廓数据。这些corner具有显著的局部特征,它们是字形的凹点,经过该点处的path会沿着顺时针急剧弯曲。计算出所有端点的角度和距离,判断是否拥有该特征,就可以检测哪些端点为corner。



function Endpoint(paths, index) {
this.index = index;
const path = paths[index[0]];
const n = path.length;
this.indices = [[index[0], (index[1] + n - 1) % n], index];
this.segments = [path[(index[1] + n - 1) % n], path[index[1]]];
this.point = this.segments[0].end;
assert(Point.valid(this.point), this.apoint);
assert(Point.equal(this.point, this.segments[1].start), path);
this.tangents = [
Point.subtract(this.segments[0].end, this.segments[0].start),
Point.subtract(this.segments[1].end, this.segments[1].start),
];
const threshold = Math.pow(MIN_CORNER_TANGENT_DISTANCE, 2);
if (this.segments[0].control !== undefined &&
Point.distance2(this.point, this.segments[0].control) > threshold) {
this.tangents[0] = Point.subtract(this.point, this.segments[0].control);
}
if (this.segments[1].control !== undefined &&
Point.distance2(this.point, this.segments[1].control) > threshold) {
this.tangents[1] = Point.subtract(this.segments[1].control, this.point);
}
this.angles = this.tangents.map(Point.angle);
const diff = Angle.subtract(this.angles[1], this.angles[0]);
this.corner = diff < -MIN_CORNER_ANGLE;
return this;
}

2.3 Corner Match Scoring 通过NN评分Corner匹配度


检测出一组corner数据后,就要对这些corner进行一对一匹配,但在匹配前还需要评判哪些corner更有可能连接起来。开源库采用神经网络算法计算corner间的匹配度,它将成为匹配算法中的权重值,使匹配结果更贴近现实情况。


const scoreCorners = (ins, out, classifier) => {
return classifier(getFeatures(ins, out));
}


import {NEURAL_NET_TRAINED_FOR_STROKE_EXTRACTION} from '/lib/net';
import {stroke_extractor} from '/lib/stroke_extractor';

Meteor.startup(() => {
const input = new convnetjs.Vol(1, 1, 8 /* feature vector dimensions */);
const net = new convnetjs.Net();
net.fromJSON(NEURAL_NET_TRAINED_FOR_STROKE_EXTRACTION);
const weight = 0.8;

const trainedClassifier = (features) => {
input.w = features;
const softmax = net.forward(input).w;
return softmax[1] - softmax[0];
}

stroke_extractor.combinedClassifier = (features) => {
return stroke_extractor.handTunedClassifier(features) +
weight*trainedClassifier(features);
}
});

2.4 Corner Matching 通过匈牙利算法进行Corner匹配


在2.3小节中已经通过神经网络产生了权重,接下来就可以使用最简单的匈牙利算法,实现corner匹配。




const matchCorners = (corners, classifier) => {
const matrix = [];
for (let i = 0; i < corners.length; i++) {
matrix.push([]);
for (let j = 0; j < corners.length; j++) {
matrix[i].push(scoreCorners(corners[i], corners[j], classifier)); //corner之间相关性
}
}
for (let i = 0; i < corners.length; i++) {
for (let j = 0; j < corners.length; j++) {
const reversed_score = matrix[j][i] - REVERSAL_PENALTY;
if (reversed_score > matrix[i][j]) {
matrix[i][j] = reversed_score;
}
}
}
return (new Hungarian(matrix)).x_match;
}

2.5 Make Bridges 连通配对端点拆分笔画


依据2.4小节的匹配结果返回一组bridge,其中每个bridge包含两个corner。跟踪轮廓的同时连通corner,就可以提取出每个笔画的轮廓数据,实现笔画拆分。值得注意的是,当遇到多个bridge时,选择与当前path构成最大角度的bridge。



const getBridges = (endpoints, classifier) => {
const result = [];
const corners = endpoints.filter((x) => x.corner);
const matching = matchCorners(corners, classifier);
for (let i = 0; i < corners.length; i++) {
const j = matching[i];
if (j <= i && matching[j] === i) {
continue;
}
result.push([Point.clone(corners[i].point), Point.clone(corners[j].point)]);
}
result.map(checkBridge);
return result;
}

const stroke_paths = extractStrokes(paths, endpoints, bridges, log);
const strokes = stroke_paths.map((x) => svg.convertPathsToSVGPath([x]));

3. Medians 笔画中点生成


在第二节中实现了笔画的拆分,得到每个笔画的轮廓数据。依据轮廓数据可以进一步生成笔画的中点骨架。轮廓决定单个笔画的绘制范围,而中点则决定了绘制的顺序和方向。结合轮廓和中点数据,就可以实现单个笔画的绘制动画。接下来就让我们一起了解,如何通过轮廓数据生成中点。



3.1 Polygon Approximation 端点加密


首先,为了提高中点生成结果的可靠性,需要先采用矢量图形的多边形近似方法进行轮廓点加密。TrueType字体利用二次贝赛尔曲线和直线来描述字形的轮廓,因此加密公式如下:




svg.getPolygonApproximation = (path, approximation_error) => {
const result = [];
approximation_error = approximation_error || 64;
for (let x of path) {
const control = x.control || Point.midpoint(x.start, x.end);
const distance = Math.sqrt(Point.distance2(x.start, x.end));
const num_points = Math.floor(distance/approximation_error);
for (let i = 0; i < num_points; i++) {
const t = (i + 1)/(num_points + 1);
const s = 1 - t;
result.push([s*s*x.start[0] + 2*s*t*control[0] + t*t*x.end[0],
s*s*x.start[1] + 2*s*t*control[1] + t*t*x.end[1]]);
}
result.push(x.end);
}
return result;
}

3.2 Polygon Voronoi 通过冯洛诺伊图(泰森多边形)生成中点


得到加密的轮廓点数据后,就可以通过泰森多边形生成中点。那什么是泰森多边形呢?


首先对一组零散控制点做如下操作:



  1. 将三个相邻控制点连成一个三角形

  2. 对三角形的每条边做垂直平分线

  3. 这些垂直平分线会组成连续多边形


这些连续多边形就是泰森多边形,又叫冯洛诺伊图(Voronoi diagram),得名于Georgy Voronoi。在IS和地理分析中经常采用泰森多边形进行快速插值,分析地理实体的影响区域,是解决邻接度问题的又一常用工具。



通过原理可以了解到,泰森多边形每个顶点是对应三角形的外接圆圆心,因此它到这些控制点的距离相等。


  var sites = [{x:300,y:300}, {x:100,y:100}, {x:200,y:500}, {x:250,y:450}, {x:600,y:150}];
// xl, xr means x left, x right
// yt, yb means y top, y bottom
var bbox = {xl:0, xr:800, yt:0, yb:600};
var voronoi = new Voronoi();
// pass an object which exhibits xl, xr, yt, yb properties. The bounding
// box will be used to connect unbound edges, and to close open cells
result = voronoi.compute(sites, bbox);
// render, further analyze, etc.

按照这个思路,可以将笔画的轮廓点作为控制点,生成泰森多边形。提取泰森多边形的顶点作为笔画中心点。



const findStrokeMedian = (stroke) => {
...
for (let approximation of [16, 64]) {
polygon = svg.getPolygonApproximation(paths[0], approximation);
voronoi = voronoi || new Voronoi;
const sites = polygon.map((point) => ({x: point[0], y: point[1]}));
const bounding_box = {xl: -size, xr: size, yt: -size, yb: size};
try {
diagram = voronoi.compute(sites, bounding_box);
break;
} catch(error) {
console.error(`WARNING: Voronoi computation failed at ${approximation}.`);
}
}
...
}

4. 笔画顺序


第三节实现了单个笔画的绘制动画,但还是需要解决笔画之间的顺序问题。解决问题的关键,就是依据汉字结构,将目标汉字不断拆解成已知顺序的字。


在开源库中提供了汉字分解数据库,关键字段如下:



以【胡】为例,?表示胡为左右结构,左边为古,右边为月。



以【湖】为例,拆解过程如下:




拆解完笔顺后,需要将所有零散的中点数据,与当前所拥有的中点再做一遍匈牙利算法匹配,最终可得到一个相对正确的笔画顺序结果,生成json文件。下面为汉字“丁”的笔顺结果文件。


{"strokes": ["M 531 651 Q 736 675 868 663 Q 893 662 899 670 Q 906 683 894 696 Q 863 724 817 744 Q 801 750 775 740 Q 712 725 483 694 Q 185 660 168 657 Q 162 658 156 657 Q 141 657 141 645 Q 140 632 160 618 Q 178 605 211 594 Q 221 590 240 599 Q 348 629 470 644 L 531 651 Z", "M 435 100 Q 407 107 373 116 Q 360 120 361 112 Q 361 103 373 94 Q 445 39 491 -5 Q 503 -15 518 2 Q 560 60 553 141 Q 541 447 548 561 Q 548 579 550 596 Q 556 624 549 635 Q 545 642 531 651 C 509 671 457 671 470 644 Q 485 629 485 573 Q 488 443 488 148 Q 487 112 477 99 Q 464 92 435 100 Z"], "medians": [[[153, 645], [177, 634], [219, 628], [416, 663], [794, 706], [823, 702], [887, 679]], [[478, 644], [518, 610], [518, 101], [495, 55], [450, 68], [369, 110]]]}

5. 相关参考


本文重点剖析了开源库中笔顺动画的关键技术,相关参考资料如下:



  1. hanziwriter.org/

  2. www.skishore.me/makemeahanz…

  3. github.com/skishore/ma…

收起阅读 »

从一个10年程序员的角度告诉你:搞懂Java面向对象有多容易?

前言: 1)java 面向对象语言,面向过程围绕过程(解决问题步骤),面向对象围绕实体(名词,特性(属性),行为(动作、方法))。它们设计思想区别在于关心核心不同的。 主流都是面向对象的。 实际开发,先按面向对象思想进行设计,具体实现时面向过程(人...
继续阅读 »


前言:



  • 1)java
    面向对象语言,面向过程围绕过程(解决问题步骤),面向对象围绕实体(名词,特性(属性),行为(动作、方法))。它们设计思想区别在于关心核心不同的。


主流都是面向对象的。


实际开发,先按面向对象思想进行设计,具体实现时面向过程(人习惯)



  • 2)java 怎么支持面向对象呢?


a. 万物皆对象,所有的类都是 Object 子类


b. java 中支持单继承,多重继承,Tiger 是 Animal 子类,Animal 是 Object 的子类。满足单继承(每次都一个父类,超类)


c. 面向对象的 4 大特性:封装、继承、多态、抽象



  • 3)封装的优点


a. 隐藏细节,开发者关注内容就少,好写代码,


b. 安全,你不需要知道我内部实现细节,private 修饰后,外部不能访问。


c. 方便修改,私有,外部不能访问,修改不影响其他类(送耦合)



  • 4)继承


a. extends 继承


a.1 继承实现类 class


a.2 继承抽象类 abstract class (必须有抽象方法,子类去实现)


b. implements 实现


实现接口 interface (里面全是抽象方法,子类去实现)


面向对象



  • 1)面向过程(早期)、面向对象(主流)、面向服务(SOA、微服务)(主流,在面向对象基础上)


  • 2)面向过程和面向对象的区别?



编程思想,做一件同样事情,做的思路不同。


思路不同在哪里?


例子:把大象放到冰箱里。(本意:把公大象放到格力冰箱中)需求变更


面向过程:开发步骤(流水账)
a. 把冰箱门打开



  • b. 把什么放进去:大象


  • c. 把大象放入冰箱


  • d. 把冰箱门关上



找出主体:名词(冰箱、大象),围绕它做事


找出动作:动词(打开、放入、关上),强调过程


面向过程:找出把名词主体,和动作(动词)连接起来,最后怎么完成整个过程!


面向对象:



  • a. 找出主体(名词:冰箱、大象)


  • b. 创建模型:(额外考虑,感觉画蛇添足)



冰箱:容大、颜色、品牌、耗电、打开、关上


大象:产地、公母、皮、腿



  • c. 执行步骤


打开冰箱,把大象放入冰箱,关上门


它考虑额外事情,目前为止用户不关心。


在实际开发中,用户不遵守他的话,他说的话不算数。


实际开发中,无法完全(合同),无法严格按合同执行,开发者就必须适应用户的需求变更。


从这一实际角度出发,面向过程思考好还是面向对象思考好!


如果按照面向过程思考,它不能适应用户需求变更,要修改代码,加班加点完成。前面考虑不够完善。


如果按照面向对象思考,它提前考虑很多细节,超过用户要求,表面上多考虑了,但是当用户需求变化,刚好就在我们多考虑范畴中!代码不需改,改动量很少。按期完成,无需额外资金投入。


面向对象要考虑很多,考虑范围,不能太广,过度设计。设计都需要人力物力。


有一个平衡点,设计多大范围合适呢? 系统分析师(高薪!)8 年


到超市购买商品


第一次用户提出需求:要购买白酒和花生米


第二次用户提出需求:要购买白酒和花生米,买猪头肉(需求变更)


第三次用户提出需求:+ 凉菜


用户变化 n 次


面向过程:


1)到哪个超市


2)挑选商品(白酒、花生米)2 种,


3)购买,结束


每次需求都要改,有可能之前代码框架都无法适应新需求,翻天覆地重做。


面向对象:


1)都有哪些超市,都有哪些商品,对超市商品全部建模 2000 种商品


2)到某个超市,挑选商品(白酒、花生米、猪头肉、凉菜)


3)购买,结束


总的来说:面向对象优于面向过程设计,主流设计思想面向对象设计!


java 是怎么支持面向对象设计的?


java 面向对象,c 面向过程,c++面向对象,python 面向对象,javascript 面向对象,vue 框架面向对象


java 四大特性:围绕面向对象而言:封装、继承、多态、抽象


封装


面向过程过程中每个细节都需要开发者去了解,封装改变这样方式,它先进行建模,把名称创建对象,设置它的属性(代表这个事物的特点)和方法(表现一些动作)


把生活中的物品抽象成 java 中的对象


对象为了简单,有些内容对外暴露,有些内容隐藏。隐藏就体现了封装。


例子:手机


如果知道手机所有细节,我们现在都用不上手机。



  • 1)对外暴露:屏幕、键盘、话筒、耳机、充电器

  • 2)隐藏:怎么通讯,运行 app


对有些内容使用者是不关心它的内部实现,手机把这些内容进行封装,用户使用就简单了。


代码如何实现封装呢?


有些功能用户不能去访问,用户不需要知道内容封装。


它需要知道,我们会单独给它接口 api


手机:
1)创建一个类:Phone


2)类中封装,对外看不到,创建属性 call、keys,私有 private (体现了封装)


3)对外暴露:怎么开发 call,怎么开发 keys?公有 public


package cn.tedu.oop;
//模拟手机建模(建立模型)需求中的名词
public class Phone {
//成员变量,可以在多个方法中直接调用
private String call; //模拟打电话特性
private String keys; //模拟手机键盘特性
//如何对外暴露私有的属性,对其进行操作。
//使用getXxx(获取)和setXxx(设置)方法来操作私有属性
//这个业界的规范,开发工具都直接支持自动产生对应属性的get和set方法
//私有属性外部不能访问,但在类的内部的方法可以直接访问
public String getCall() {
return call;
}
//外部怎么去设置成员变量值呢?setCall方法的参数
public void setCall(String call) {
//前面成员变量,后面是参数,参数就保存了用户设置值,
//以后用户使用get方法就可以获取新的值
//参数名和成员变量的名称重复,怎么区分谁是谁呢?
//this.value就可以区分,this代表本类,对象,this.value代表成员变量,就不是参数名
this.call = call;
}
public String getKeys() {
return keys;
}//加入Java开发交流君样:756584822一起吹水聊天
public void setKeys(String keys) {
//警察,监听电话,
//用户只管调用setKeys方法,它并不知道这块代码
if( keys.equals("110") ) { //判断keys值是否为110
System.out.println("通知警察");
}
this.keys = keys;
}
}

在这里插入图片描述


封装的好处


1)把不让外界知道的信息就隐藏起来,外部无法操作。代码比较安全,外部无法操作。


2)代码只能内部处理。当代码修改,所有调用地方都要随之改变,这种结构紧耦合。如果代码只能内部修改,修改后,外部丝毫不影响,这种结构松耦合。程序能实现松耦合就松耦合。封装就实现松耦合结构。内部修改不影响其他代码。


3)封装后,里面程序实现细节,对应调用者来说不关心,只关心如何使用。把复杂问题变简单。


继承


什么叫继承?


java 中继承和生活继承是一样一样的。父类(父亲)和子类(自己)。父亲父亲,子类子类。


java 继承单继承,c 语言允许多继承(c 语言代码质量出错,很难找的其中一个原因)。在这里插入图片描述
结论:java 中单继承,但是可以多层


java 中如何实现继承关系?


实现继承关系提供 2 个方式:


1)extends 关键字(继承):语法 extends 后面跟类(class 实现类、abstract class 抽象类)


Tiger extends Animal


Eagle extends Animal


特点:Animal 是一个实现类,它具体实现 eat 方法


抽象类特点:它有部分实现(父类自己实现)和部分规定不实现的(子类去实现)


Tiger extends AbstractAnimal(抽象类中有抽象方法,抽象方法父类不实现,压到子类去实现)


2)implements 关键字(实现):语法 implements 后面跟接口(interface)


接口特点:所有方法都是抽象方法,一点活都不干,它指手画脚(它要规定子类实现方法)


为什么要使用继承?


我们可以从父类继承它的属性和方法,在子类中直接调用父类资源(属性和方法),方法和属性都是 public。在这里插入图片描述
在这里插入图片描述
通过对上面两个类的观察:


1)它们有共性,eat 方法一样


2)它们有个性,Tiger 类它有自己的 run()方法,Eagle 类它有自己的 fly()方法。


有共性有不同!在这里插入图片描述
缺点:


共性的方法,出现在多个类中,如果业务需要修改,要修改多处,工作量大,容易造成失误,这个类改,那个类


忘改,造成结果不一致!


继承


解决办法?就是继承!


1)要把共性方法抽取出来,放到一个单独类中 Animal


2)把共性方法就从当前类中删除


3)两个类连接起来,使用继承,Tiger extends Animal,可以在子类中直接访问父类方法 eat()
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


抽象类


在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


接口


在这里插入图片描述
在这里插入图片描述
在这里插入图片描述


实现类和抽象类和接口区别


在这里插入图片描述


为什么需要抽象类?


学框架,框架中很多抽象类。例如:spring 框架


框架要做很多底层公用事情,让我们写代码利用框架,程序更加健壮,更加安全,


业务需求私有事情,还得我们去实现


公用框架实现,私有我们自己实现,我们自己写代码怎么和框架对接。框架进行规定!


规范私有类(抽象方法声明)


为什么需要接口?


提倡面向接口开发,你可以实现接口,别人可不可以接口。


java JDBC 数据库一套规范,java 自身规定接口,其他厂商去实现


mysql 数据库厂商,Mysql 的实现;oracle 数据库厂商,oracle 的实现。


小结


今日给大家分享的是面向对象,这对于很多小白来说很友好的,大家都能看得懂!
生命不止坚毅鱼奋斗,有梦想才是有意义的追求
给大家推荐一个免费的学习交流群:
最后,祝大家早日学有所成,拿到满意offer,快速升职加薪,走上人生巅峰。
Java开发交流君样:756584822

收起阅读 »

不懂泛型,怎么装逼,一文把泛型说的明明白白,安排!!!

目录 前言 1、泛型的概念 2、泛型的使用 3、泛型原理,泛型擦除 3.1 IDEA 查看字节码 3.2 泛型擦除原理 4、?和 T 的区别 5、super extends 6、注意点 1、静态方法无法访问类的泛型 2、创建之后无法修改类...
继续阅读 »

图片


目录


前言


1、泛型的概念


2、泛型的使用


3、泛型原理,泛型擦除


3.1 IDEA 查看字节码


3.2 泛型擦除原理


4、?和 T 的区别


5、super extends


6、注意点


1、静态方法无法访问类的泛型


2、创建之后无法修改类型


3、类型判断问题


4、创建类型实例


7、总结




前言


 


泛型是Java中的高级概念,也是构建框架必备技能,比如各种集合类都是泛型实现的,今天详细聊聊Java中的泛型概念,希望有所收获。记得点赞,关注,分享哦。


1、泛型的概念


泛型的作用就是把类型参数化,也就是我们常说的类型参数


平时我们接触的普通方法的参数,比如public void fun(String s);参数的类型是String,是固定的


现在泛型的作用就是再将String定义为可变的参数,即定义一个类型参数T,比如public static <T> void fun(T t);这时参数的类型就是T的类型,是不固定的


泛型常见的字母有以下:


? 表示不确定的类型
T (type) 表示具体的一个java类型
K V (key value) 分别代表java键值中的Key Value
E (element) 代表Element

这些字母随意使用,只是代表类型,也可以用单词。


2、泛型的使用


泛型有三种使用方式,分别为:泛型类、泛型接口、泛型方法。


类的使用地方是


方法的使用地方



  • Java泛型类


  • Java泛型方法


  • Java泛型接口



/**
* @author 香菜
*/
public class Player<T> {// 泛型类
  private T name;
  public T getName() {
      return name;
  }
  public void setName(T name) {
      this.name = name;
  }
}


 


public class Apple extends Fruit {
  public <T> void getInstance(T t){// 泛型方法
      System.out.println(t);
  }
}


public interface Generator<T> {
   
      public T next();
   
  }


3、泛型原理,泛型擦除


3.1 IDEA 查看字节码


1、创建Java文件,并编译,确认生成了class


图片


2、idea ->选中Java 文件 ->View


图片


3.2 泛型擦除原理


我们通过例子来看一下,先看一个非泛型的版本:


图片


从字节码可以看出,在取出对象的的时候我们做了强制类型转换。


下面我们给出一个泛型的版本,从字节码的角度来看看:


图片


在编译过程中,类型变量的信息是能拿到的。所以,set方法在编译器可以做类型检查,非法类型不能通过编译。但是对于get方法,由于擦除机制,运行时的实际引用类型为Object类型。为了“还原”返回结果的类型,编译器在get之后添加了类型转换。所以,在Player.class文件main方法主体第18行有一处类型转换的逻辑。它是编译器自动帮我们加进去的


所以在泛型类对象读取和写入的位置为我们做了处理,为代码添加约束。


泛型参数将会被擦除到它的第一个边界(边界可以有多个,重用 extends 关键字,通过它能给与参数类型添加一个边界)。编译器事实上会把类型参数替换为它的第一个边界的类型。如果没有指明边界,那么类型参数将被擦除到Object。


4、?和 T 的区别


?使用场景 和Object一样,和C++的Void 指针一样,基本上就是不确定类型,可以指向任何对象。一般用在引用。


T 是泛型的定义类型,在运行时是确定的类型。


5、super extends


通配符限定:


<? extends T>:子类型的通配符限定,以查询为主,比如消费者集合场景


<? super T>:超类型的通配符限定,以添加为主,比如生产者集合场景


super 下界通配符 ,向下兼容子类及其子孙类, T super Child 会被擦除为 Object


extends 上界通配符  ,向下兼容子类及其子孙类, T extends Parent 会被擦除为 Parent



class Fruit {}
class Apple extends Fruit {}
class FuShi extends Apple {}
class Orange extends Fruit {}

import java.util.ArrayList;
import java.util.List;

public class Aain {
 public static void main(String[] args) {
       //上界
       List<? extends Fruit> topList = new ArrayList<Apple>();
       topList.add(null);
       //add Fruit对象会报错
       //topList.add(new Fruit());
       Fruit fruit1 = topList.get(0);

       //下界
       List<? super Apple> downList = new ArrayList<>();
       downList.add(new Apple());
       downList.add(new FuShi());
       //get Apple对象会报错
       //Apple apple = downList.get(0);
}

上界 <? extend Fruit> ,表示所有继承Fruit的子类,但是具体是哪个子类,但是肯定是Fruit


下界 <? super Apple>,表示Apple的所有父类,包括Fruit,一直可以追溯到老祖宗Object 。


归根结底可以用一句话表示,那就是编译器可以支持向上转型,但不支持向下转型。具体来讲,我可以把Apple对象赋值给Fruit的引用,但是如果把Fruit对象赋值给Apple的引用就必须得用cast。


6、注意点


1、静态方法无法访问类的泛型


图片


可以看到Idea 提示无法引用静态上下文。


2、创建之后无法修改类型


List<Player> 无法插入其他的类型,已经确定类型的不可以修改类型


3、类型判断问题


问题:因为类型在编译完之后无法获取具体的类型,所以在运行时是无法判断类的类型。


我们可以通过下面的代码来解决泛型的类型信息由于擦除无法进行类型判断的问题:


/**
* 判断类型
* @author 香菜
* @param <T>
*/
public class GenClass<T> {
   Class<?> classType;
   public GenClass(Class<?> classType) {
       this.classType = classType;
  }
   public boolean isInstance(Object object){
       return classType.isInstance(object);
  }
}

解决方案:我们通过在创建对象的时候在构造函数中传入具体的class类型,然后通过这个Class对象进行类型判断。


4、创建类型实例


问题:泛型代码中不能new T()的原因有两个,一是因为擦除,不能确定类型;而是无法确定T是否包含无参构造函数。


在之前的文章中,有一个需求是根据不同的节点配置实例化创建具体的执行节点,即根据IfNodeCfg 创建具体的IfNode.


/**
* 创建实例
* @author 香菜
*/
public abstract class AbsNodeCfg<T> {
   public abstract T getInstance();
}

public class IfNodeCfg extends AbsNodeCfg<IfNode>{
   @Override
   public IfNode getInstance() {
       return new IfNode();
  }
}

 



/**
* 创建实例
* @author 香菜
*/
public class IfNode {
}

解决方案:通过上面的方式可以根据具体的类型,创建具体的实例,扩展的时候直接继承AbsNodeCfg,并且实现具体的节点就可以了。


7、总结


泛型相当于创建了一组的类,方法,虚拟机中没有泛型类型对象的概念,在它眼里所有对象都是普通对象


图片


有疑问的可以留言,我们一起讨论,没有问题的也可以留言,我们交个朋友


打字不容易,点赞,转发,关注三连,谢谢大家支持。

收起阅读 »

程序员五一被拉去相亲,结果彻底搞懂了HTTP常用状态码

我有一个朋友…… 叫小星,是个北漂程序员。 小星年纪不小了,还是个单身狗。家里很着急,小星也很着急。 可是,小星起身一看,眼前一闪闪闪闪闪闪闪闪闪…… ——全是秃头抠脚大汉…… 前一阵子好不容易来个实习生小姑娘,分给小星带,小星高兴坏了,结果姑娘...
继续阅读 »


我有一个朋友……


叫小星,是个北漂程序员。


小星年纪不小了,还是个单身狗。家里很着急,小星也很着急。


可是,小星起身一看,眼前一闪闪闪闪闪闪闪闪闪……


——全是秃头抠脚大汉……


img


前一阵子好不容易来个实习生小姑娘,分给小星带,小星高兴坏了,结果姑娘没呆三天,受不了公司的九九六跑了。


所以,部门彻底沦为了和尚部门,拔剑四顾心茫然,不见妹子只见男。



404(Not Found):服务器无法根据客户端的请求找到资源(网页)



茫然


老妈打电话又催了,小星说工作忙,没有女同事。


老妈问和你一起长大的小美还联系吗?


小美已经嫁做人妇,孩子都会叫爸爸了。



  • 301(Moved Permanently):永久移动。请求的资源已被永久的移动到新URI。


痛哭


那你大学时谈过的小静呢?


小静已经重新开始,找了新的男朋友。



302(Found):临时移动。与301类似。但资源只是临时被移动。



哭泣

那我帮你安排相亲好了。


什么……好吧。


五一回家,老妈给小星安排了相亲。小星蔫头巴脑地去见相亲的小姐姐了,没想到,小姐姐还挺白净,小星一下子就支棱起来了。


小星高兴地和妹子聊了起来。妹子说她最近去过西安旅游,平时会去游泳,喜欢吃一些小吃。


——这,九九六的工作节奏基本剥夺了小星的业余生活,小星冷汗连连,只能“嗯”、“啊”。


终于,妹子问了一句,你的工作怎么样?


小星的脸上一下子泛起了红光,眼神里带着一种神圣的色彩。


你知道能应对亿级流量的高并发架构如何搭建吗?你知道高并发下保证幂等性的几种方式吗?你知道保证Redis高可用的几种方法吗……啊吧啊吧



400(Bad Request):客户端请求的语法错误,服务器无法理解。



什么东西


妹子说,我吹了风,感觉头有点疼,今天就先到这吧。



500(Internal Server Error):服务器内部错误,无法完成请求。



尴尬又不失礼貌的微笑


小星垂头丧气地回家了,老妈一看小星这个样子,就知道什么情况。


— 没有关系,明天我给你安排了第二场,好好休息准备,明天好好表现。


小星夜里失眠了,辗转反侧。


明天的姑娘是什么样?和照片上差别大吗?应该很温柔吧?……


到了半夜,小星终于睡着了。


小星做了一个好梦,他和一个叫小萌的姑娘在一起了。过了一段时间,小星想?乛?乛?,小萌:? ?° ?? ?° ?,讨厌,,才确定关系多久。



403(Forbidden):服务器理解请求客户端的请求,但是拒绝执行此请求。



害羞


但是耐不住小星的软磨硬泡,还是……结果闹出人命了,但是孩子还不能生。


因为没有结婚证和准生证。



401(Unauthorized):请求需要有通过HTTP认证(BASIC认证,DIGEST认证)的认证信息。



突然领证


后来,小星和小萌结婚了,生了一个可爱的孩子,一家三口过上了幸福的生活。



200(OK):请求成功。



突然,一个容嬷嬷跳了出来。


臭小子,彩礼钱没给够,挨我一针吧!


小星一下子惊醒。


还好,只是一场梦。


天已经亮了,小星强打精神,去参加今天的相亲了。


至于结果,标题里已经说明了。


表情







End!

纯属瞎侃,请勿当真!——“任由你 自由的 耗在我苦中作乐”


参考:


【1】:浪漫故事:常见HTTP状态码的另类解析

收起阅读 »

Android开发基础之控件CheckBox

目录 一、基础属性 二、自定义样式 1、去掉CheckBox的勾选框 2、自定义背景颜色 3、自定义勾选框的背景图片 三、监听事件       &nb...
继续阅读 »





       


一、基础属性























































1、layout_width 宽度
2、layout_height 高度
3、id 设置组件id
4、text 设置显示的内容
5、textColor 设置字体颜色
6、textStyle 设置字体风格:normal(无效果)、bold(加粗)、italic(斜体)
7、textSize 字体大小,单位常用sp
8、background 控件背景颜色
9、checked 默认选中该选项
10、orientation 内部控件排列的方向,例如水平排列或垂直排列
11、paddingXXX 内边距,该控件内部控件间的距离
12、background 控件背景颜色或图片

       
1、layout_width
2、layout_height


        组件宽度和高度有4个可选值,如下图:
在这里插入图片描述


       
3、id


// activity_main.xml
android:id="@+id/cb1" // 给当前控件取个id叫cb1

// MainActivity.java
CheckBox cb1=findViewById(R.id.cb1); // 按id获取控件
cb1.setText("hh"); // 对这个控件设置显示内容

        如果在.java和.xml文件中对同一属性进行了不同设置,比如.java中设置控件内容hh,.xml中设置内容为aa,最后显示的是.java中的内容hh。


       
4、text
       可以直接在activity_main.xml中写android:text="嘻嘻",也可以在strings.xml中定义好字符串,再在activity_main.xml中使用这个字符串。


// strings.xml
<string name="str1">嘻嘻</string>

// activity_main.xml
android:text="@string/str1"

       
5、textColor
       与text类似,可以直接在activity_main.xml中写android:textColor="#FF0000FF",也可以在colors.xml中定义好颜色,再在activity_main.xml中使用这个颜色。


       
       


9、checked
       checked=“true”,默认这个RadioButton是选中的。该属性只有在RadioGroup中每个RadioButton都设置了id的条件下才有效。


       


       


10、orientation


内部控件的排列方式:



  • orientation=“vertical”,垂直排列

  • orientation=“horizontal”,水平排列


       


11、paddingXXX


内边距,该控件与内部的控件间的距离,常用的padding有以下几种:



  • padding,该控件与内部的控件间的距离

  • paddingTop,该控件与内部的控件间的上方的距离

  • paddingBottom,该控件与内部的控件间的下方的距离

  • paddingRight,该控件与内部的控件间的左侧的距离

  • paddingLeft,该控件与内部的控件间的右侧的距离


       


程序示例:


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="match_parent"
android:layout_width="match_parent"
android:orientation="vertical">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/tv1"
android:text="你喜欢做什么?"
android:textSize="50sp"
android:textColor="@color/i_purple_700">

</TextView>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb1"
android:text="吃饭"
android:textSize="50sp"
android:checked="true">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb2"
android:text="睡觉"
android:textSize="50sp"
android:checked="true">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb3"
android:text="工作"
android:textSize="50sp"
android:checked="true">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb4"
android:text="玩耍"
android:textSize="50sp"
android:checked="true">

</CheckBox>
</LinearLayout>

效果:


       


       


       


二、自定义样式


       


1、去掉CheckBox的勾选框


       在CheckBox的属性里写上button="@null"
程序示例:


<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb1"
android:text="吃饭"
android:textSize="50sp"
android:button="@null">

</CheckBox>

效果:


“吃饭”前面的勾选框没有了,不过这样做,你最好设置选中时一个背景,未选中时一个背景,不然像图上那样根本看不出来选没选中“吃饭”。


       


2、自定义背景颜色


新建一个选择器selector
在这里插入图片描述
在这里插入图片描述


       


你取的名字.xml文件内编写代码:



  • item android:state_checked=“false” , 未选中这个CheckBox时的样式

  • item android:state_checked=“true” ,选中这个CheckBox时的样式

  • solid android:color="@color/yellow_100" ,设置实心的背景颜色

  • stroke android:width=“10dp” ,设置边框粗细
               android:color="@color/i_purple_700" ,设置边框颜色

  • corners android:radius=“50dp” ,设置边框圆角大小


程序示例:
blue_selector.xml


<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:state_checked="false">
<shape android:shape="rectangle">
<solid android:color="@color/blue_100"></solid>
<stroke android:color="@color/blue_700" android:width="5dp"></stroke>
<corners android:radius="30dp"></corners>
</shape>
</item>
<item android:state_checked="true">
<shape android:shape="rectangle">
<solid android:color="@color/blue_500"></solid>
<corners android:radius="30dp"></corners>
</shape>
</item>
</selector>

activity_main.xml


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="match_parent"
android:layout_width="match_parent"
android:orientation="vertical">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/tv1"
android:text="你喜欢做什么?"
android:textSize="50sp"
android:textColor="@color/i_purple_700"
android:paddingBottom="20dp"
android:paddingTop="20dp">

</TextView>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb1"
android:text="吃饭"
android:textSize="50sp"
android:background="@drawable/blue_selector">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb2"
android:text="睡觉"
android:textSize="50sp"
android:background="@drawable/purple_selector">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb3"
android:text="工作"
android:textSize="50sp"
android:background="@drawable/blue_selector">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb4"
android:text="玩耍"
android:textSize="50sp"
android:background="@drawable/purple_selector">

</CheckBox>
</LinearLayout>

都未选:


都选中:


       


       


3、自定义勾选框的背景图片


导入背景图片:
在这里插入图片描述
在这里插入图片描述
       


然后新建一个选择器selector
在这里插入图片描述
在这里插入图片描述


       


你取的名字.xml文件内编写代码:



  • item android:state_checked=“false” , 未选中这个CheckBox时的样式

  • item android:state_checked=“true” ,选中这个CheckBox时的样式

  • drawable="@drawable/ic_pink_heart",设置背景图片


程序示例:
bg_checkbox.xml


<?xml version="1.0" encoding="utf-8"?>
<selector xmlns:android="http://schemas.android.com/apk/res/android">
<item android:drawable="@drawable/ic_pink_heart" android:state_checked="true"></item>
<item android:drawable="@drawable/ic_heart_broken" android:state_checked="false"></item>
</selector>

activity_main.xml里写button="@drawable/bg_checkbox",使用写好的背景文件bg_checkbox.xml


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_height="match_parent"
android:layout_width="match_parent"
android:orientation="vertical">

<TextView
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/tv1"
android:text="你喜欢做什么?"
android:textSize="50sp"
android:textColor="@color/i_purple_700"
android:paddingBottom="20dp"
android:paddingTop="20dp">

</TextView>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb1"
android:text="吃饭"
android:textSize="50sp"
android:button="@drawable/bg_checkbox">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb2"
android:text="睡觉"
android:textSize="50sp"
android:button="@drawable/bg_checkbox">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb3"
android:text="工作"
android:textSize="50sp"
android:button="@drawable/bg_checkbox">

</CheckBox>
<CheckBox
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:id="@+id/cb4"
android:text="玩耍"
android:textSize="50sp"
android:button="@drawable/bg_checkbox">

</CheckBox>
</LinearLayout>

都未选:


都选中:


当然这个图标换成√或者×都是可以的。


       


       


       


三、监听事件


        在MainActivity.java内添加监听,当CheckBox的选中状态发生变化时,就会执行写好的操作:


public class MainActivity extends AppCompatActivity {
private CheckBox cb1;
private CheckBox cb2;
private CheckBox cb3;
private CheckBox cb4;

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

// 获取控件id
cb1=findViewById(R.id.cb1);
cb2=findViewById(R.id.cb2);
cb3=findViewById(R.id.cb3);
cb4=findViewById(R.id.cb4);
// 监听选中状态
cb1.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
Toast.makeText(MainActivity.this,isChecked?"选中":"未选中",Toast.LENGTH_SHORT).show();
}
});
cb2.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
Toast.makeText(MainActivity.this,isChecked?"选中":"未选中",Toast.LENGTH_SHORT).show();
}
});
cb3.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
Toast.makeText(MainActivity.this,isChecked?"选中":"未选中",Toast.LENGTH_SHORT).show();
}
});
cb4.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
Toast.makeText(MainActivity.this,isChecked?"选中":"未选中",Toast.LENGTH_SHORT).show();
}
});
}
}

       


选中某个CheckBox时,弹出选中提示信息:


       

收起阅读 »

Android自定义弧型View

好久没动手玩View自定义,有点生疏了。效果如下 思路很简单,onDraw绘制弧线、绘制Text canvas.drawArc(oval, startAngle, sweepAngle, false, paint); canvas.drawText...
继续阅读 »


好久没动手玩View自定义,有点生疏了。效果如下


思路很简单,onDraw绘制弧线、绘制Text



canvas.drawArc(oval, startAngle, sweepAngle, false, paint);

canvas.drawText(integralValue, rectF.centerX(), baseline, textPaint);


draw 动画效果实现:invalidate


canvas.drawArc(oval, startAngle, i, false, paint);

if(i<sweepAngle){
i = i+10;//sweepAngle :240,所以这里+10没问题,具体细节具体修改
getHandler().postDelayed(new Runnable() {
@Override
public void run() {
invalidate();
}
},50);
}

绘制的效果差别有点大不理想,先给画笔添加抗锯齿和画笔圆角


textPaint.setAntiAlias(true);
textPaint.setTypeface(Typeface.DEFAULT_BOLD);

drawText让文字居中对齐,一定要算好边界和baseLine



RectF rectF = new RectF(borderWidth * 2 + arcMargin, borderWidth * 2 + arcMargin, getMeasuredWidth() - arcMargin - borderWidth * 2, getMeasuredHeight() - arcMargin - borderWidth * 2);

//计算baseline
Paint.FontMetrics fontMetrics = textPaint.getFontMetrics();
float distance = (fontMetrics.bottom - fontMetrics.top) / 2 - fontMetrics.bottom;
float baseline = rectF.centerY() + distance;
canvas.drawText(integralValue, rectF.centerX(), baseline, textPaint);

积分商城文本背景可以用shape绘制,这里直接代码搞一个drawable


   /**
* 设置圆角背景
*
* @param
* @param radiiValue 设置图片四个角圆形半径
* @return
*/
@SuppressLint("WrongConstant")
public static GradientDrawable getBackgroundShapeDrawable(int color, float radiiValue) {
float[] radii = new float[] { radiiValue, radiiValue, radiiValue, radiiValue, radiiValue, radiiValue, radiiValue,radiiValue };
GradientDrawable drawable = new GradientDrawable();
drawable.setShape(GradientDrawable.RECTANGLE);
drawable.setGradientType(GradientDrawable.RECTANGLE);
drawable.setCornerRadii(radii);
drawable.setColor(color);
return drawable;
}

居中文字大小不能固定值,防止超出弧型,要跟据文字长度动态调整



textPaint.setTextSize(getIntegralTextSize(integralValue));

protected int getIntegralTextSize(String text) {
int flag = 80;
if (text.length() == 8) {
flag = 70;
} else if (text.length() == 9) {
flag = 60;
} else if (text.length() >= 10) {
flag = 50;
}

return flag;
}

源码就不上传了,实现起来还是不难用了十几分钟,等下班咯

收起阅读 »

音视频开发必备基础知识点整理

IM
日常工作中都会接触到音视频的开发,比如目前工作中都会涉及到 TSPlayer、IjkPlayer、MediaPlayer 提供播放能力,不管是什么 Player,其上层调用都是大同小异,但是具体实现以及能够支持的能力各不相同,要想继续深入就必须深入音视频的学习...
继续阅读 »


日常工作中都会接触到音视频的开发,比如目前工作中都会涉及到 TSPlayer、IjkPlayer、MediaPlayer 提供播放能力,不管是什么 Player,其上层调用都是大同小异,但是具体实现以及能够支持的能力各不相同,要想继续深入就必须深入音视频的学习,Android 开发的几个主要方向分别是应用、Framework、音视频、NDK等,如果继续在 Android 领域,这些坑还是是必须要填的,主要内容如下:



1.视频编码
2.音频编码
3.多媒体播放组件
4.帧率
5.分辨率
6.编码格式
7.封装格式
8.码率
9.颜色空间
10.采样率
11.量化精度
12.声道




视频编码


视频编码指的是通过特定的压缩技术,将某个视频文件格式转换为另一种视频格式文件的方式,视频传输中主要编解码标准如下:



  • 运动静止图像专家组的 M-JPEG



    • M-JPEG 是一种图像压缩编码标准,是 Motion-JPEG 的简称,JPEG 标准主要是用来处理静止图像,而 M-JPEG 把运动的视频序列作为连续的静止图像来处理,这种压缩方式单独完整地压缩每一帧,在编辑过程中可随机存储每一帧,可进行精确到帧的编辑,M-JPEG 只对帧内的空间冗余进行压缩,不对帧间的时间冗余进行压缩,故压缩效率不高。


  • 国际标准化组织(ISO)运动图像专家组的 MPEG 系列标准



    • MPEG 标准主要有五个:MPEG-1、MPEG-2、MPEG-4、MPEG-7 及 MPEG-21 等,MPEG 标准的视频压缩编码技术主要利用了具有运动补偿的帧间压缩编码技术以减小时间冗余度,利用 DCT 技术以减小图像的空间冗余度,利用熵编码则在信息表示方面减小了统计冗余度。这几种技术的综合运用,大大增强了压缩性能。


  • 国际电联(ITU-T)的 H.261、H.263、H.264等



    • H.261:第一个实用的数字视频解码标准,采用的压缩算法是运动补偿帧间预测与分块 DCT 相结合的混合编码,其运动补偿使用用全像素精度和环路滤波,支持 CIF 和 QCIF 两种分辨率。

    • H.263:H.263 与 H.261 编码算法一样,但是做了一点改善,使得 H.263 标准在低码率下能够提供比 H.261 更好的图像效果,其运动补偿使用半像素精度,支持 CIF、QCIF 、SQCIF、4CIF和16CIF 五种分辨率。

    • H.264:H.264则是由两个组织 ISO 和 ITU-T 联合组建的联合视频组(JVT)共同制定的新数字视频编码标准,所以它既是 ITU-T 的H.264,又是 ISO/IEC 的 MPEG-4 高级视频编码(Advanced Video Coding,AVC)的第 10 部分,因此,不论是MPEG-4 AVC、MPEG-4 Part 10,还是 ISO/IEC 14496-10,都是指 H.264,H.264 是基于传统框架的混合编码系统,做了局部优化,注重编码效率和可靠性。H.264 在具有高压缩比的同时还拥有高质量流畅的图像,经过 H.264 压缩的视频数据,在网络传输过程中所需要的带宽更少,是压缩率最高的视频压缩标准。



音频编码


常见的音频编解码标准如下:



  • ITU:G.711、G.729 等

  • MPEG:MP3、AAC 等

  • 3GPP:AMR、AMR-WB、AMR-WB+等

  • 还有企业制定的标准,如 Dolby AC-3、DTS 、WMA 等


常见的介绍如下:



  • MP3(MPEG-1 audio layer 3):一种音频压缩技术,它被设计用来大幅度地降低音频数据量,利用 MPEG Audio Layer 3 的技术,将音乐以 1:10 甚至 1:12 的压缩率,压缩成容量较小的文件,而对于大多数用户来说重放的音质与最初的不压缩音频相比没有明显的下降,它是利用人耳对高频声音信号不敏感的特性,将时域波形信号转换成频域信号,并划分成多个频段,对不同的频段使用不同的压缩率,对高频加大压缩比(甚至忽略信号),对低频信号使用小压缩比,保证信号不失真,这样就相当于抛弃人耳基本听不到的高频声音,只保留能听到的低频部分,从而对音频进行一定压缩,此外 MP3 属于有损压缩的文件格式。


  • AAC:Advanced Audio Coding 的缩写,最初是基于 MPEG-2 的音频编码技术,MPEG-4 出现后,AAC 重新集成了其特性,且加入了SBR 技术和 PS 技术,为了区别于传统的 MPEG-2 AAC 又称为MPEG-4 AAC,AAC 是一种专为声音数据设计的文件压缩格式,相较 MP3,AAC 格式的音质更佳,文件更小,但是 AAC 是一种有损压缩格式,随着大容量设备的出现,其优势将越来越小。


  • WMA:Windows Media Audio 的缩写,是微软公司开发的一系列音频编解码器,也指相应的数字音频编码格式,WMA 包括四种不同的编解码器:WMA,原始的WMA编解码器,作为 MP3 和 RealAudio 编解码器的竞争者;WMA Pro,支持更多声道和更高质量的音频[;WMA Lossless,无损编解码器;WMA Voice,用于储存语音,使用的是低码率压缩。一些使用 Windows Media Audio 编码格式编码其所有内容的纯音频 ASF 文件也使用 WMA 作为扩展名,其特点是支持加密,非法拷贝到本地是无法播放的,WMA 也属于有损压缩的文件格式。



更多音视频编解码标准可以参考:音频编解码标准


多媒体播放组件


Android 多媒体播放组件包含 MediaPlayer、MediaCodec、OMX 、StageFright、AudioTrack 等,具体如下:



  • MediaPlayer:为应用层提供的播放控制接口

  • MediaCodec:提供访问底层媒体编解码器的接口

  • OpenMAX :Open Media Acceleration,又缩写为 OMX,开放多媒体加速层,是一个多媒体应用程序标准,Android 主要的多媒体引擎StageFright 是透过 IBinder 使用 OpenMax,用于编解码处理。

  • StageFright:Android 2.2 开始引入用来替换预设的媒体播放引擎 OpenCORE,Stagefright 是位于 Native 层的媒体播放引擎,内置了基于软件的编解码器,且适用于热门媒体格式,其编解码功能是利用OpenMAX 框架,引入的是 OpenCORE 的 omx-component 部分,在 Android 中是以共享库的形式存在,对应 libstagefright.so。

  • AudioTrack:管理和播放单个音频资源,仅支持 PCM 流,如大多数的 WAV 格式的音频文件就是就是 PCM 流,这类音频文件支持 AudioTrack 直接进行播放。


常见的多媒体框架及解决方案


常见的多媒体框架及解决方案有 VLC 、 FFmpeg 、 GStream 等,具体如下:



  • VLC : 即 Video LAN Client,是一款自由、开源的跨平台多媒体播放器及框架 。

  • FFmpeg:多媒体解决方案,不是多媒体框架,广泛用于音视频开发中。

  • GStreamer : 一套构建流媒体应用的开源多媒体框架 。


帧率


帧率是用于测量显示帧数的量度。单位为「每秒显示帧数」(Frame per Second,FPS)或「赫兹,Hz」,表示每秒的帧数(FPS)或者说帧率表示图形处理器处理场时每秒钟能够更新的次数,高的帧率可以得到更流畅、更逼真的动画,一般来说 30fps 就是可以接受的,但是将性能提升至 60fps 则可以明显提升交互感和逼真感,但是一般来说超过 75fps 一般就不容易察觉到有明显的流畅度提升了,如果帧率超过屏幕刷新率只会浪费图形处理的能力,因为监视器不能以这么快的速度更新,这样超过刷新率的帧率就浪费掉了。


分辨率


视频分辨率是指视频成像产品所形成的图像大小或尺寸,常见的 1080P、4K 等有代表什么呢,P 本身的含义是逐行扫描,表示视频像素的总行数,1080P 表示总共有 1080 行的像素数,而 K 表示视频像素的总列数,4K 表示有 4000 列的像素数,通常来说,1080P 就是指 1080 x 1920 的分辨率,4 k 指 3840 x 2160 的分辨率。


刷新率


刷新率就是屏幕每秒画面被刷新的次数,刷新率分为垂直刷新率和水平刷新率,一般提到的刷新率通常指垂直刷新率,垂直刷新率表示屏幕的图象每秒钟重绘多少次,也就是每秒钟屏幕刷新的次数,以 Hz(赫兹)为单位,刷新率越高越好,图象就越稳定,图像显示就越自然清晰,对眼睛的影响也越小,刷新频率越低,图像闪烁和抖动的就越厉害,眼睛疲劳得就越快,一般来说,如能达到 80Hz 以上的刷新频率就可完全消除图像闪烁和抖动感,眼睛也不会太容易疲劳。


编码格式


针对音视频来说,编码格式对应的就是音频编码和视频编码,对照前面的音频编码标准和视频编码标准,每种编码标准都对应的编码算法,其目的是通过一定编码算法实现数据的压缩、减少数据的冗余。


封装格式


直接看下百度百科的关于封装格式的介绍,封装格式(也叫容器),就是将已经编码压缩好的视频轨和音频轨按照一定的格式放到一个文件中,也就是说仅仅是一个外壳,或者大家把它当成一个放视频轨和音频轨的文件夹也可以,说得通俗点,视频轨相当于饭,而音频轨相当于菜,封装格式就是一个碗,或者一个锅,用来盛放饭菜的容器。


码率


码率,也就是比特率(Bit rate),指单位时间内传输或处理的比特的数量,单位为 bps(bit per second)也可表示为 b/s,比特率越高,单位时间传送的数据量(位数)越大,多媒体行业在指音频或视频在单位时间内的数据传输率时通常使用码率,单位是 kbps,一般来说,如果是 1M 的宽带,在网上只能看码流不超过 125kbps 的视频,超过 125kbps 的视频只能等视频缓冲才能顺利观看。


码率一般分为固定码率和可变码率:



  • 固定码率会保证码流的码率恒定,但是会牺牲视频质量,比如为了保证码率恒定,某些图像丰富的内容就是失去某些图像细节而变得模糊。

  • 可变码率指的是输出码流的码率是可变的,因为视频信源本身的高峰信息量是变化的,从确保视频传输质量和充分利用信息的角度来说,可变码率视频编码才是最合理的。


码率的高低与视频质量和文件提交成正比,但当码率超过一定数值后,对视频质量没有影响。


颜色空间



  • YUV:一种颜色编码方法,一般使用在在影像处理组件中,YUV 在对照片或视频编码时,考虑到人类的感知能力,允许降低色度的带宽,其中 Y 表示明亮度、U 表示色度、V 表示浓度,Y′UV、YUV、YCbCr、YPbPr 所指涉的范围,常有混淆或重叠的情况。从历史的演变来说,其中 YUV 和 Y’UV 通常用来编码电视的模拟信号,而 YCbCr 则是用来描述数字的影像信号,适合视频与图片压缩以及传输,例如 MPEG、JPEG,现在 YUV 通常已经在电脑系统上广泛使用。

  • RGB:原色光模式,又称 RGB 颜色模型或红绿蓝颜色模型,是一种加色模型,将红(Red)、绿(Green)、[蓝(Blue)三原色的色光以不同的比例相加,以合成产生各种色彩光,目前的大多数显示器都采用 RGB 这种颜色标准。


YUV 主要用于优化彩色视频信号的传输,使其向后相容老式黑白电视,与 RGB 视频信号传输相比,它最大的优点在于只需占用极少的带宽。


采样率


采样率,表示每秒从连续信号中提取并组成离散信号的采样个数,用赫兹(Hz)来表示,采样率是指将模拟信号转换成数字信号时的采样频率,人耳能听到的声音一般在 20Hz~20KHz 之间,根据采样定理,采样频率大于信号中最高频率的 2 倍时,采样之后的数字信号便能完整的反应真实信号,常见的采样率如下:



  • 8000 Hz:电话所用采样率, 对于人的说话已经足够

  • 11025 Hz:AM调幅广播所用采样率

  • 22050 Hz 和 24,000 Hz:FM调频广播所用采样率

  • 44100Hz:音频CD,常用于 MPEG-1 音频(VCD,SVCD,MP3)所用采样率

  • 47,250 Hz:商用 PCM 录音机所用采样率

  • 48,000 Hz:miniDV、数字电视、DVD、DAT、电影和专业音频所用的数字声音所用采样率


CD 音乐的标准采样频率为 44.1KHz,这也是目前声卡与计算机作业间最常用的采样频率,目前比较盛行的蓝光的采样率就相当的高,达到了 192kHz。而目前的声卡,绝大多数都可以支持 44.1kHz、48kHz、96kHz,高端产品可支持 192kHz 甚至更高,总之,采样率越高,获得的声音文件质量越好,占用存储空间也就越大。


量化精度


声波在转换为数字信号的过程中不只有采样率影响原始声音的完整性,还有一个重要影响因素是量化精度,采样频率针对的是每秒钟所采样的数量,而量化精度则是对于声波的振幅进行切割,切割的数量是以最大振幅切成 2 的 n 次方计算,n 就是 bit 数,而 bit 数就是音频分辨率。


另外,bit 的数目还决定了声波振幅的范围(即动态范围,最大音量与最小音量的差距),如果这个位数越大,则能够表示的数值越大,描述波形更精确,每一个 Bit 的数据可以记录约等于 6dB 动态的信号,一般来说,16Bit 可以提供最大 96dB 的动态范围(加高频颤动后 只有 92dB),据此可以推断出 20Bit 可以达到 120dB 的动态范围,动态范围大了,会有什么好处呢?动态范围是指系统的输出噪音功率和最大不失真音量功率的比值,这个值越大,则系统可以承受很高的动态。


声道


声道指声音在录制或播放时在不同空间位置采集或回放的相互独立的音频信号,所以声道数也就是声音录制时的音源数量或回放时相应的扬声器数量,常见声道有单声道、立体声道、4 声道、5.1 声道、7.1 声道等 ,具体如下:



  • 单声道:设置一个扬声器。

  • 立体声道:把单声道一个扬声器扩展为左右对称的两个扬声器,声音在录制过程中被分配到两个独立的声道,从而达到了很好的声音定位效果,这种技术在音乐欣赏中显得尤为有用,昕众可以清晰地分辨出各种乐器来自何方,从而使音乐更富想象力,更加接近临场感受。立体声技术广泛应用于自 Sound Blaster Pro 以后的大量声卡,成为了 影响深远的音频标准。

  • 4 声道:4 声道环绕规定了 4 个发音点,分别是前左、前右、后左、后右,昕众则被包围在中间,同时还建议增加一个低音音箱,以加强对低频信号的回放处理,这也就是如今 4.1 声道音箱系统广泛流行的原因,就整体效果而言,4 声道系统可以为听众带来来自多个不 同方向的声音环绕,可以获得身 临各种不同环境的昕觉感受,给用户以全新的体验。

  • 5.1 声道:其实 5.1 声道系统来源于 4.1 声道系统,将环绕声道一分为二,分为左环绕和右环绕,中央位置增加重低音效果。

  • 7.1 声道:7.1 声道系统在 5.1 声道系统的基础上又增加了中左和中右两个发音点,简单来说就是在听者的周围建立起一套前后相对平衡的声场,增加了 后中声场声道。


最后



大家如果还想了解更多Android 开发、音视频开发相关的更多知识点,可以点进我的GitHub项目中:https://github.com/733gh/Android-T3自行查看,里面记录了许多的Android 知识点。最后还请大家点点赞支持下!!!




收起阅读 »

【JavaWeb】关于WebSocket的IM在线聊天技术

IM
最近在弄IM的在线聊天,发现layim又停摆了,所以下决心看看以前学的socket技术,这次的想法是不用swing,使用javaweb的jsp实现在线聊天。 我计划的大致实现步骤分这样几大步: 1、首先实现简单的demo。 2、然后结合线程,实现多客户端连接...
继续阅读 »

最近在弄IM的在线聊天,发现layim又停摆了,所以下决心看看以前学的socket技术,这次的想法是不用swing,使用javaweb的jsp实现在线聊天。


我计划的大致实现步骤分这样几大步:
1、首先实现简单的demo。
2、然后结合线程,实现多客户端连接服务端发送消息;
3、实现后台服务端转发客户端消息至所有客户端,同时在客户端显示;
4、使用前端jsp或者html展示的界面使用js技术发送信息并接收处理。


5、这是后话这期不弄,优化界面,使用html5。






也伴随着HTML5推出的WebSocket,真正实现了Web的实时通信,使B/S模式具备了C/S模式的实时通信能力。WebSocket的工作流程是这样的:浏览器通过JavaScript向服务端发出建立WebSocket连接的请求,在WebSocket连接建立成功后,客户端和服务端就可以通过TCP连接传输数据。因为WebSocket连接本质上是TCP连接,不需要每次传输都带上重复的头部数据,所以它的数据传输量比轮询和Comet技术小了很多。这里就不详细地介绍WebSocket规范,主要介绍下WebSocket在Java Web中的实现。


也就是我demo




新建一个dynamic web项目:


客户端(Web主页)代码:



<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML>
<html>
<head>
<base href="<%=basePath%>">
<title>My WebSocket</title>
</head>

<body>
Welcome<br/>
<input id="text" type="text" /><button οnclick="send()">Send</button> <button οnclick="closeWebSocket()">Close</button>
<div id="message">
</div>
</body>

<script type="text/javascript">
var websocket = null;

//判断当前浏览器是否支持WebSocket
if('WebSocket' in window){
websocket = new WebSocket("ws://localhost:8080/MyWebSocket/websocket");
}
else{
alert('Not support websocket')
}

//连接发生错误的回调方法
websocket.onerror = function(){
setMessageInnerHTML("error");
};

//连接成功建立的回调方法
websocket.onopen = function(event){
setMessageInnerHTML("open");
}

//接收到消息的回调方法
websocket.onmessage = function(){
setMessageInnerHTML(event.data);
}

//连接关闭的回调方法
websocket.onclose = function(){
setMessageInnerHTML("close");
}

//监听窗口关闭事件,当窗口关闭时,主动去关闭websocket连接,防止连接还没断开就关闭窗口,server端会抛异常。
window.onbeforeunload = function(){
websocket.close();
}

//将消息显示在网页上
function setMessageInnerHTML(innerHTML){
document.getElementById('message').innerHTML += innerHTML + '<br/>';
}

//关闭连接
function closeWebSocket(){
websocket.close();
}

//发送消息
function send(){
var message = document.getElementById('text').value;
websocket.send(message);
}
</script>
</html>



Java Web后台代码


package com.jy.im.websocket;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;

import javax.websocket.OnClose;
import javax.websocket.OnError;
import javax.websocket.OnMessage;
import javax.websocket.OnOpen;
import javax.websocket.Session;
import javax.websocket.server.ServerEndpoint;

//该注解用来指定一个URI,客户端可以通过这个URI来连接到WebSocket。类似Servlet的注解mapping。无需在web.xml中配置。
@ServerEndpoint("/websocket")
public class MyWebSocket {
//静态变量,用来记录当前在线连接数。应该把它设计成线程安全的。
private static int onlineCount = 0;

//concurrent包的线程安全Set,用来存放每个客户端对应的MyWebSocket对象。若要实现服务端与单一客户端通信的话,可以使用Map来存放,其中Key可以为用户标识
private static CopyOnWriteArraySet<MyWebSocket> webSocketSet = new CopyOnWriteArraySet<MyWebSocket>();

//与某个客户端的连接会话,需要通过它来给客户端发送数据
private Session session;

/**
* 连接建立成功调用的方法
* @param session 可选的参数。session为与某个客户端的连接会话,需要通过它来给客户端发送数据
*/
@OnOpen
public void onOpen(Session session){
this.session = session;
webSocketSet.add(this); //加入set中
addOnlineCount(); //在线数加1
System.out.println("有新连接加入!当前在线人数为" + getOnlineCount());
}

/**
* 连接关闭调用的方法
*/
@OnClose
public void onClose(){
webSocketSet.remove(this); //从set中删除
subOnlineCount(); //在线数减1
System.out.println("有一连接关闭!当前在线人数为" + getOnlineCount());
}

/**
* 收到客户端消息后调用的方法
* @param message 客户端发送过来的消息
* @param session 可选的参数
*/
@OnMessage
public void onMessage(String message, Session session) {
System.out.println("来自客户端的消息:" + message);

//群发消息
for(MyWebSocket item: webSocketSet){
try {
item.sendMessage(message);
} catch (IOException e) {
e.printStackTrace();
continue;
}
}
}

/**
* 发生错误时调用
* @param session
* @param error
*/
@OnError
public void onError(Session session, Throwable error){
System.out.println("发生错误");
error.printStackTrace();
}

/**
* 这个方法与上面几个方法不一样。没有用注解,是根据自己需要添加的方法。
* @param message
* @throws IOException
*/
public void sendMessage(String message) throws IOException{
this.session.getBasicRemote().sendText(message);
//this.session.getAsyncRemote().sendText(message);
}

public static synchronized int getOnlineCount() {
return onlineCount;
}

public static synchronized void addOnlineCount() {
MyWebSocket.onlineCount++;
}

public static synchronized void subOnlineCount() {
MyWebSocket.onlineCount--;
}
}







收起阅读 »