稀释1
稀释1

WebRTC -ios

1.podfile 文件

source 'https://github.com/CocoaPods/Specs.git'
 platform :ios, '9.0'

target 'iosWebRTCDemo' do
  # Comment the next line if you don't want to use dynamic frameworks
  use_frameworks!
pod 'GoogleWebRTC','1.1.24595'

pod 'ReactiveObjC'
pod 'SocketRocket','0.5.1'
pod 'HGAlertViewController', '~> 1.0.1'

  target 'iosWebRTCDemoTests' do
    inherit! :search_paths
    # Pods for testing
  end

  target 'iosWebRTCDemoUITests' do
    # Pods for testing
  end

end

 [[WebRTCHelper shareInstance] connectServer:@"172.27.104.54" port:@"9090/SocketServer"];
  1. WebRTCHelper.h
//
//  WebRTCHelper.h
//  WebRTC_new
//
//  Created by
//  Copyright © 2020年
//

#import 
#import 
#import 
#import 
#import 

//@import SocketIO;

typedef enum : NSUInteger {
    WebSocketConnectSuccess = 0,
    WebSocketConnectField,
    WebSocketConnectClosed,
} WebSocketConnectState;

@protocol WebRTCHelperDelegate;
@protocol WebRTCHelperFrindDelegate;

@interface WebRTCHelper : NSObject

/**
 * 单例
 */
+(instancetype)shareInstance;

/*注释*/
@property (nonatomic,weak) id delegate;
/*注释*/
@property (nonatomic,weak) id friendDelegate;

/**
 * 与服务器建立连接
 * @param server 服务器地址
 * @param port 端口号
 */
-(void)connectServer:(NSString *)server port:(NSString *)port;
/**
 * 切换摄像头
 */
- (void)swichCamera:(BOOL)_usingFrontCamera;
/**
 * 是否显示本地视频
 */
- (void)showLocaolCamera:(BOOL)_usingCamera;
/**
 * 退出房间
 */
-(void)exitRoom;

@end

@protocol WebRTCHelperDelegate 
@optional
/**
 * 获取到发送信令消息
 * @param webRTCHelper 本类
 * @param message 消息内容
 */
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper receiveMessage:(NSString *)message;
/**
 * 获取本地的localVideoStream数据
 * @param webRTCHelper 本类
 * @param steam 视频流
 * @param userId 用户标识
 */
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper setLocalStream:(RTCMediaStream *)steam userId:(NSString *)userId;
/**
 * 获取远程的remoteVideoStream数据
 * @param webRTCHelper 本类
 * @param stream 视频流
 * @param userId 用户标识
 */
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper addRemoteStream:(RTCMediaStream *)stream userId:(NSString *)userId;
/**
 * 某个用户退出后，关闭用户的连接
 * @param webRTCHelper 本类
 * @param userId 用户标识
 */
- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper closeWithUserId:(NSString *)userId;

/**
 * 获取socket连接状态
 * @param webRTCHelper 本类
 * @param connectState 连接状态，分为
 WebSocketConnectSuccess 成功,
 WebSocketConnectField, 失败
 WebSocketConnectClosed 关闭
 */
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper socketConnectState:(WebSocketConnectState)connectState;
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper capturerSession:(AVCaptureSession *)captureSession;
@end

@protocol WebRTCHelperFrindDelegate 
@optional
/**
 * 获取房间内所有的用户（除了自己）
 * @param friendList 用户列表
 */
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper gotFriendList:(NSArray *)friendList;
/**
 * 获取新加入的用户信息
 * @param friendId 新用户的id
 */
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper gotNewFriend:(NSString *)friendId;
/**
 * 获取离开房间用户的信息
 * @param friendId 离开用户的ID
 */
-(void)webRTCHelper:(WebRTCHelper *)webRTCHelper removeFriend:(NSString *)friendId;
@end

3 .WebRTCHelper.m

//
//  WebRTCHelper.m
//  WebRTC_new
//
//  Created by
//  Copyright © 2020年
//

#import "WebRTCHelper.h"

#define kAPPID  @"1234567890abcdefg"
#define kDeviceUUID [[[UIDevice currentDevice] identifierForVendor] UUIDString]

//google提供的
static NSString *const RTCSTUNServerURL = @"stun:stun.l.google.com:19302";
//static NSString *const RTCSTUNServerURL2 = @"stun:23.21.150.121";
static NSString *const RTCSTUNServerURL2 =@"stun:global.stun.twilio.com:3478?transport=udp";


@interface WebRTCHelper()
{
    SRWebSocket *_socket;
    NSString *_server;
    
    RTCPeerConnectionFactory *_factory;
    RTCMediaStream *_localStream;
    
    NSString *_myId;
    NSMutableDictionary *_connectionDic; // 存放 所有用户 对应的链接集合
    NSMutableArray *_connectionIdArray; // 存放 房间人数的 id
    
    NSMutableArray *ICEServers;
  
    //是否显示我的视频流（默认为yes，显示；no为不显示）
    BOOL _usingCamera;
    
    RTCCameraVideoCapturer * _capture;
}

@end

@implementation WebRTCHelper

static WebRTCHelper * instance = nil;

+(instancetype)shareInstance{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[[self class] alloc] init];
        [instance initData];
    });
    return instance;
}

-(void)initData{
    _connectionDic = [NSMutableDictionary dictionary];
    _connectionIdArray = [NSMutableArray array];
    _usingCamera = YES;
}


#pragma mark -提供给外部的方法

/**
 * 与服务器进行连接
 */
- (void)connectServer:(NSString *)server port:(NSString *)port{
    _server = server;
    NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:[NSString stringWithFormat:@"ws://%@:%@",server,port]] cachePolicy:NSURLRequestUseProtocolCachePolicy timeoutInterval:20];

    _socket = [[SRWebSocket alloc] initWithURLRequest:request];
    _socket.delegate = self;
    [_socket open];

    
}


/**
 *  退出房间
 */
- (void)exitRoom
{
    _localStream = nil;
    [_capture stopCapture];
    _capture = nil;
    NSArray *arr =_connectionIdArray.copy;
    [arr enumerateObjectsUsingBlock:^(NSString *obj, NSUInteger idx, BOOL * _Nonnull stop) {
      [self closePeerConnection:obj];

    }];
    [_socket close];
}

/**
 * 切换摄像头
 */
- (void)swichCamera:(BOOL)_usingFrontCamera{

    [self switchFrontBackCamera:_usingFrontCamera];
}

/**
 * 是否显示本地摄像头
 */
- (void)showLocaolCamera:(BOOL)_usingCamera{
    _usingCamera = _usingCamera;
    //如果为空，则创建点对点工厂
    if (!_factory)
    {
        //设置SSL传输
        [RTCPeerConnectionFactory initialize];
        [self create_factory];
    }
    //如果本地视频流为空
    if (!_localStream)
    {
        //创建本地流
        [self createLocalStream];
    }
//    [_capture stopCapture];
    //创建连接
    [self createPeerConnections];
    
    //添加
    [self addStreams];
    [self createOffers];
}

#pragma mark -内部方法
/**
 *  关闭peerConnection
 *
 *  @param connectionId <#connectionId description#>
 */
- (void)closePeerConnection:(NSString *)connectionId
{
    RTCPeerConnection *peerConnection = [_connectionDic objectForKey:connectionId];
    if (peerConnection)
    {
        [peerConnection close];
    }
    [_connectionIdArray removeObject:connectionId];
    [_connectionDic removeObjectForKey:connectionId];
    dispatch_async(dispatch_get_main_queue(), ^{
        if ([self->_delegate respondsToSelector:@selector(webRTCHelper:closeWithUserId:)])
        {
            [self->_delegate webRTCHelper:self closeWithUserId:connectionId];
        }
    });
}


/**
 *  创建点对点连接
 *
 *  @param connectionId connectionId description
 *
 *  @return <#return value description#>
 */
- (RTCPeerConnection *)createPeerConnection:(NSString *)connectionId
{
    //如果点对点工厂为空
    if (!_factory)
    {
        [self create_factory];
    }
    
    //得到ICEServer
    if (!ICEServers) {
        ICEServers = [NSMutableArray array];
        [ICEServers addObject:[self defaultSTUNServer]];
    }
    
    //用工厂来创建连接
    RTCConfiguration *configuration = [[RTCConfiguration alloc] init];
    configuration.iceServers = ICEServers;
    RTCPeerConnection *connection = [_factory peerConnectionWithConfiguration:configuration constraints:[self creatPeerConnectionConstraint] delegate:self];
    return connection;
}

- (RTCMediaConstraints *)creatPeerConnectionConstraint
{
    RTCMediaConstraints *constraints = [[RTCMediaConstraints alloc] initWithMandatoryConstraints:@{kRTCMediaConstraintsOfferToReceiveAudio:kRTCMediaConstraintsValueTrue,kRTCMediaConstraintsOfferToReceiveVideo:kRTCMediaConstraintsValueTrue} optionalConstraints:@{@"DtlsSrtpKeyAgreement":@"true"}];
    
    return constraints;
}

//初始化STUN Server （ICE Server）
- (RTCIceServer *)defaultSTUNServer{
    return [[RTCIceServer alloc] initWithURLStrings:@[RTCSTUNServerURL,RTCSTUNServerURL2]];
}


/**
 *  为所有连接添加流
 */
- (void)addStreams
{
    //给每一个点对点连接，都加上本地流
    NSDictionary *dic = [_connectionDic copy];
    [dic enumerateKeysAndObjectsUsingBlock:^(NSString *key, RTCPeerConnection *obj, BOOL * _Nonnull stop) {
        if (!self->_localStream)
        {
            [self createLocalStream];
        }
        [obj addStream:self->_localStream];
    }];
}
/**
 *  创建所有连接
 */
- (void)createPeerConnections
{
    //从我们的连接数组里快速遍历
    NSArray *arr = _connectionIdArray.copy;
    [arr enumerateObjectsUsingBlock:^(NSString *obj, NSUInteger idx, BOOL * _Nonnull stop) {
        
        //根据连接ID去初始化 RTCPeerConnection 连接对象
        RTCPeerConnection *connection = [self createPeerConnection:obj];
        
        //设置这个ID对应的 RTCPeerConnection对象
        [self->_connectionDic setObject:connection forKey:obj];
       
    }];
}


/**
 * 创建本地视频流
 */
-(void)createLocalStream{
    _localStream = [_factory mediaStreamWithStreamId:@"ARDAMS"];
    //音频
    RTCAudioTrack * audioTrack = [_factory audioTrackWithTrackId:@"ARDAMSa0"];
    [_localStream addAudioTrack:audioTrack];
    NSArray *captureDevices = [RTCCameraVideoCapturer captureDevices];
    AVCaptureDevicePosition position =  AVCaptureDevicePositionFront;
    AVCaptureDevice * device = captureDevices[0];
    for (AVCaptureDevice *obj in captureDevices) {
        if (obj.position == position) {
            device = obj;
            break;
        }
    }
    
    //检测摄像头权限
    AVAuthorizationStatus authStatus = [AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo];
    if(authStatus == AVAuthorizationStatusRestricted || authStatus == AVAuthorizationStatusDenied)
    {
        NSLog(@"相机访问受限");
        if ([_delegate respondsToSelector:@selector(webRTCHelper:setLocalStream:userId:)])
        {
            
            [_delegate webRTCHelper:self setLocalStream:nil userId:_myId];
        }
    }
    else
    {
        if (device)
        {
            
            RTCVideoSource *videoSource = [_factory videoSource];
              [videoSource adaptOutputFormatToWidth:640 height:480 fps:20];
         _capture = [[RTCCameraVideoCapturer alloc] initWithDelegate:videoSource];
//            AVCaptureDeviceFormat * format = [[RTCCameraVideoCapturer supportedFormatsForDevice:device] lastObject];
             AVCaptureDeviceFormat* format = device.activeFormat;

            RTCVideoTrack *videoTrack = [_factory videoTrackWithSource:videoSource trackId:@"ARDAMSv0"];
            __weak RTCCameraVideoCapturer *weakCapture = _capture;
            [_localStream addVideoTrack:videoTrack];
            if ([self->_delegate respondsToSelector:@selector(webRTCHelper:capturerSession:)])
            {
                [self->_delegate webRTCHelper:self capturerSession:weakCapture.captureSession];
            }
      
              [weakCapture stopCapture];
            [weakCapture startCaptureWithDevice:device format:format fps:20 completionHandler:^(NSError * error) {
                NSLog(@"11111111");
            }];
        }
        else
        {
            NSLog(@"该设备不能打开摄像头");
            if ([_delegate respondsToSelector:@selector(webRTCHelper:setLocalStream:userId:)])
            {
                [_delegate webRTCHelper:self setLocalStream:nil userId:_myId];
            }
        }
    }
}
// 切换摄像头
-(void)switchFrontBackCamera:(BOOL)usingFrontCamera
{
    if (_localStream == nil)
        return;
    
    NSArray *captureDevices = [RTCCameraVideoCapturer captureDevices];
    AVCaptureDevicePosition position = usingFrontCamera ? AVCaptureDevicePositionFront : AVCaptureDevicePositionBack;
    AVCaptureDevice * device = nil;
    for (AVCaptureDevice *obj in captureDevices) {
        if (obj.position == position) {
            device = obj;
            break;
        }
    }
    
//    AVCaptureDeviceFormat * format = [[RTCCameraVideoCapturer supportedFormatsForDevice:device] lastObject];
     AVCaptureDeviceFormat* format = device.activeFormat;
    [_capture stopCapture];
    [_capture startCaptureWithDevice:device format:format fps:15 completionHandler:^(NSError * _Nonnull error)
     {
         
     }];
}
/**
 *  视频的相关约束
 */
- (RTCMediaConstraints *)localVideoConstraints
{
    NSDictionary *mandatory = @{kRTCMediaConstraintsMaxWidth:@640,kRTCMediaConstraintsMinWidth:@640,kRTCMediaConstraintsMaxHeight:@480,kRTCMediaConstraintsMinHeight:@480,kRTCMediaConstraintsMinFrameRate:@15};
    
    RTCMediaConstraints *constraints = [[RTCMediaConstraints alloc] initWithMandatoryConstraints:mandatory optionalConstraints:@{@"DtlsSrtpKeyAgreement":@"true"}];
    return constraints;
}

/**
 * 创建offer
 */
-(void)createOffer:(RTCPeerConnection *)peerConnection{
    if (peerConnection == nil) {
        peerConnection = [self createPeerConnection:nil];
    }
    
    [peerConnection offerForConstraints:[self offerOranswerConstraint] completionHandler:^(RTCSessionDescription * _Nullable sdp, NSError * _Nullable error) {
        if (error == nil) {
//             RTCSessionDescription *newSdp = [self descriptionForDescription:sdp preferredVideoCodec:@"H264"];
            __weak RTCPeerConnection * weakPeerConnction = peerConnection;
            [peerConnection setLocalDescription:sdp completionHandler:^(NSError * _Nullable error) {
                if (error == nil) {
                    [self setSessionDescriptionWithPeerConnection:weakPeerConnction];
                }
            }];
        }
    }];

}
/**
 *  为所有连接创建offer
 */
- (void)createOffers
{
    //给每一个点对点连接，都去创建offer
    NSDictionary *dic = [_connectionDic copy];
    [dic enumerateKeysAndObjectsUsingBlock:^(NSString *key, RTCPeerConnection *obj, BOOL * _Nonnull stop) {
        [self createOffer:obj];
    }];
}

/**
 *  设置offer/answer的约束d
 */
- (RTCMediaConstraints *)offerOranswerConstraint
{
    NSMutableDictionary * dic = [@{kRTCMediaConstraintsOfferToReceiveAudio:kRTCMediaConstraintsValueTrue,kRTCMediaConstraintsOfferToReceiveVideo:kRTCMediaConstraintsValueTrue} mutableCopy];
    [dic setObject:(_usingCamera ? kRTCMediaConstraintsValueTrue : kRTCMediaConstraintsValueFalse) forKey:kRTCMediaConstraintsOfferToReceiveVideo];
    RTCMediaConstraints *constraints = [[RTCMediaConstraints alloc] initWithMandatoryConstraints:dic optionalConstraints:@{@"DtlsSrtpKeyAgreement":@"true"}];
    return constraints;
}

// Called when setting a local or remote description.
//当一个远程或者本地的SDP被设置就会调用
- (void)setSessionDescriptionWithPeerConnection:(RTCPeerConnection *)peerConnection
{
    NSLog(@"%s",__func__);
    NSString *currentId = [self getKeyFromConnectionDic:peerConnection];
   
    if (currentId == nil)
    {
        NSLog(@"找不到用户");
        return;
    }
    
    
    //判断，当前连接状态为，收到了远程点发来的offer，这个是进入房间的时候，尚且没人，来人就调到这里
    if (peerConnection.signalingState == RTCSignalingStateHaveRemoteOffer)
    {
        //创建一个answer,会把自己的SDP信息返回出去
        [peerConnection answerForConstraints:[self offerOranswerConstraint] completionHandler:^(RTCSessionDescription * _Nullable sdp, NSError * _Nullable error) {
            __weak RTCPeerConnection *obj = peerConnection;
            [peerConnection setLocalDescription:sdp completionHandler:^(NSError * _Nullable error) {
                [self setSessionDescriptionWithPeerConnection:obj];
            }];
        }];
    }
    //判断连接状态为本地发送offer
    else if (peerConnection.signalingState == RTCSignalingStateHaveLocalOffer)
    {
        if (peerConnection.localDescription.type == RTCSdpTypeAnswer)
        {
            NSDictionary *dic = @{@"event": @"answer", @"data": @{@"sdp": peerConnection.localDescription.sdp}, @"sender": _myId, @"receiver":currentId};
            NSData *data = [NSJSONSerialization dataWithJSONObject:dic options:NSJSONWritingPrettyPrinted error:nil];
            NSString *jsonString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
            [_socket send:jsonString];
            
        }
        //发送者,发送自己的offer
        else if(peerConnection.localDescription.type == RTCSdpTypeOffer)
        {
            NSDictionary *dic = @{@"event": @"offer", @"data": @{@"sdp": peerConnection.localDescription.sdp}, @"sender": _myId, @"receiver":currentId};
            NSData *data = [NSJSONSerialization dataWithJSONObject:dic options:NSJSONWritingPrettyPrinted error:nil];
             NSString *jsonString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
            [_socket send:jsonString];
        }
    }
    else if (peerConnection.signalingState == RTCSignalingStateStable)
    {
        if (peerConnection.localDescription.type == RTCSdpTypeAnswer)
        {
            NSDictionary *dic = @{@"event": @"answer", @"data": @{@"sdp": peerConnection.localDescription.sdp}, @"sender": _myId, @"receiver":currentId};
            NSData *data = [NSJSONSerialization dataWithJSONObject:dic options:NSJSONWritingPrettyPrinted error:nil];
             NSString *jsonString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
            [_socket send:jsonString];
        }
    }
    
}


#pragma mark RTCPeerConnectionDelegate
/**获取远程视频流*/
- (void)peerConnection:( RTCPeerConnection *)peerConnection didAddStream:( RTCMediaStream *)stream {
    NSString * userId = [self getKeyFromConnectionDic:peerConnection];
    dispatch_async(dispatch_get_main_queue(), ^{
        if ([self->_delegate respondsToSelector:@selector(webRTCHelper:addRemoteStream:userId:)]) {
            [self->_delegate webRTCHelper:self addRemoteStream:stream userId:userId];
        }
    });
}

/**RTCIceConnectionState 状态变化*/
- (void)peerConnection:(nonnull RTCPeerConnection *)peerConnection didChangeIceConnectionState:(RTCIceConnectionState)newState {
    NSLog(@"%s",__func__);
    NSLog(@"newState=====%ld",(long)newState);
    NSString * connectId = [self getKeyFromConnectionDic:peerConnection];
   
    if (newState == RTCIceConnectionStateDisconnected) {
//         [self createOffer:peerConnection];
        //断开connection的连接
//        dispatch_async(dispatch_get_main_queue(), ^{
//            if ([self->_delegate respondsToSelector:@selector(webRTCHelper:closeWithUserId:)]) {
//                [self->_delegate webRTCHelper:self closeWithUserId:connectId];
//            }
//            [self closePeerConnection:connectId];
//        });
    }
}
//[candidate.sdpMid isEqualToString:@"audio"]?@"audio":@"video"
/**获取到新的candidate*/
- (void)peerConnection:(RTCPeerConnection *)peerConnection didGenerateIceCandidate:(RTCIceCandidate *)candidate{
    NSLog(@"+++%s",__func__);
    
    NSString *currentId = [self getKeyFromConnectionDic: peerConnection];
    
    NSDictionary *dic = @{
                          @"event": @"_ice_candidate",
                          @"data":@{
                                  @"candidate":@{
                                          @"sdpMid":candidate.sdpMid ,
                                          @"sdpMLineIndex":[NSNumber numberWithInteger:candidate.sdpMLineIndex],
                                          @"candidate": candidate.sdp
                                          }
                                  
                                  } ,
                          @"sender":_myId ,
                          @"receiver":currentId
                          };
     NSLog(@"%d-------%@",candidate.sdpMLineIndex,candidate.sdpMid);
    NSData *data = [NSJSONSerialization dataWithJSONObject:dic options:NSJSONWritingPrettyPrinted error:nil];
      NSString *jsonString = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
    [_socket send:jsonString];
}

/**删除某个视频流*/
- (void)peerConnection:(nonnull RTCPeerConnection *)peerConnection didRemoveStream:(nonnull RTCMediaStream *)stream {
    NSLog(@"%s",__func__);
}

- (void)peerConnectionShouldNegotiate:(RTCPeerConnection *)peerConnection{
    NSLog(@"%s,line = %d object = %@",__FUNCTION__,__LINE__,peerConnection);
}

- (void)peerConnection:(nonnull RTCPeerConnection *)peerConnection didRemoveIceCandidates:(nonnull NSArray *)candidates {
    NSLog(@"%s,line = %d object = %@",__FUNCTION__,__LINE__,candidates);
}

- (void)peerConnection:(RTCPeerConnection *)peerConnection didChangeSignalingState:(RTCSignalingState)stateChanged{
     NSString *currentId = [self getKeyFromConnectionDic: peerConnection];
    
    NSLog(@"stateChanged = %ld=======currentId=====%@",(long)stateChanged,currentId);
}
- (void)peerConnection:(RTCPeerConnection *)peerConnection didChangeIceGatheringState:(RTCIceGatheringState)newState{
    NSLog(@"newState = %ld",newState);
}


#pragma mark -消息相关
-(void)peerConnection:(RTCPeerConnection *)peerConnection didOpenDataChannel:(RTCDataChannel *)dataChannel{
    
}

#pragma mark -视频分辨率代理
- (void)capturer:(nonnull RTCVideoCapturer *)capturer didCaptureVideoFrame:(nonnull RTCVideoFrame *)frame {
    
}
-(void)create_factory
{
    if(!_factory)
    {
        RTCInitializeSSL();
        RTCDefaultVideoEncoderFactory *encodeFac = [[RTCDefaultVideoEncoderFactory alloc]init];
        RTCDefaultVideoDecoderFactory *decodeFac = [[RTCDefaultVideoDecoderFactory  alloc]init];
        NSArray *arrCodecs  = [encodeFac supportedCodecs];
//        RTCVideoCodecInfo *info = arrCodecs[2];
//         RTCVideoCodecInfo *info1 = arrCodecs[2];
//        [encodeFac setPreferredCodec :info];
    
        _factory = [[RTCPeerConnectionFactory alloc]initWithEncoderFactory:encodeFac decoderFactory:decodeFac];
//        _factory = [[RTCPeerConnectionFactory alloc] init];
        }
   
}
#pragma mark --open
-(void)openWith:(NSDictionary*)dic{
    //得到data
    //得到所有的连接
    NSArray *connections = dic[@"remoteIds"];
    //加到连接数组中去
    [_connectionIdArray addObjectsFromArray:connections];
    
    //拿到给自己分配的ID
    _myId = dic[@"sender"];
    
    //如果为空，则创建点对点工厂
    if (!_factory)
    {
        //设置SSL传输
        [RTCPeerConnectionFactory initialize];
        [self create_factory];
        
    }
  
    //如果本地视频流为空
    if (!_localStream)
    {
        //创建本地流
        [self createLocalStream];
    }
    //创建连接
    [self createPeerConnections];
    
    //添加
    [self addStreams];
//    [self createOffers];
    
    //获取房间内所有用户的代理回调
    dispatch_async(dispatch_get_main_queue(), ^{
      
        if ([self->_friendDelegate respondsToSelector:@selector(webRTCHelper:gotFriendList:)]) {
            [self->_friendDelegate webRTCHelper:self gotFriendList:connections];
        }
    });
}

#pragma mark --_ice_candidate
-(void)_ice_candidateWith:(NSDictionary *)dic{
    NSDictionary *dataDic = dic[@"data"];
    NSString *socketId = dic[@"sender"];
    NSDictionary *candidateDic =dataDic[@"candidate"];
    NSString *sdpMid = candidateDic[@"sdpMid"];
    
    int sdpMLineIndex = [candidateDic[@"sdpMLineIndex"] intValue];
    NSString *sdp = candidateDic[@"candidate"];
    //生成远端网络地址对象
    RTCIceCandidate *candidate = [[RTCIceCandidate alloc] initWithSdp:sdp sdpMLineIndex:sdpMLineIndex sdpMid:sdpMid];
    //拿到当前对应的点对点连接
    RTCPeerConnection *peerConnection = [_connectionDic objectForKey:socketId];
    //添加到点对点连接中
    [peerConnection addIceCandidate:candidate];
}
#pragma mark ------join
-(void)joinWith:(NSDictionary *)dic{
    //拿到新人的ID
    NSString *socketId = dic[@"sender"];
    
    //再去创建一个连接
    RTCPeerConnection *peerConnection = [self createPeerConnection:socketId];
    if (!_localStream)
    {
        [self createLocalStream];
    }
    //把本地流加到连接中去
    [peerConnection addStream:_localStream];
    //连接ID新加一个
    [_connectionIdArray addObject:socketId];
    //并且设置到Dic中去
    [_connectionDic setObject:peerConnection forKey:socketId];

   [self createOffer:peerConnection];
    
    dispatch_async(dispatch_get_main_queue(), ^{
        //设置新加入用户代理
        if ([self->_friendDelegate respondsToSelector:@selector(webRTCHelper:gotNewFriend:)]) {
            [self->_friendDelegate webRTCHelper:self gotNewFriend:socketId];
        }
    });
}

#pragma mark --remove
-(void)removeWith:(NSDictionary *)dic{
    //得到socketId，关闭这个peerConnection
    NSString *socketId = dic[@"sender"];
    [self closePeerConnection:socketId];
    
    //设置关闭某个用户聊天代理回调
    dispatch_async(dispatch_get_main_queue(), ^{
//        if ([self->_delegate respondsToSelector:@selector(webRTCHelper:closeWithUserId:)])
//        {
//            [self->_delegate webRTCHelper:self closeWithUserId:socketId];
//        }
        //设置退出房间用户代理回调
        if ([self->_friendDelegate respondsToSelector:@selector(webRTCHelper:removeFriend:)]) {
            [self->_friendDelegate webRTCHelper:self removeFriend:socketId];
        }
    });
}

#pragma mark --offer
-(void)offerWith:(NSDictionary *)dic{
    NSDictionary *dataDic = dic[@"data"];
    //拿到SDP
    NSString *sdp = dataDic[@"sdp"];
    NSString *socketId =  dic[@"sender"];
    
    //拿到这个点对点的连接
    RTCPeerConnection *peerConnection = [_connectionDic objectForKey:socketId];
    //根据类型和SDP 生成SDP描述对象
    RTCSessionDescription *remoteSdp = [[RTCSessionDescription alloc] initWithType:RTCSdpTypeOffer sdp:sdp];
//    RTCSessionDescription *newSdp = [self descriptionForDescription:remoteSdp preferredVideoCodec:@"H264"];
    //设置给这个点对点连接
    __weak RTCPeerConnection *weakPeerConnection = peerConnection;
    [peerConnection setRemoteDescription:remoteSdp completionHandler:^(NSError * _Nullable error) {
        [self setSessionDescriptionWithPeerConnection:weakPeerConnection];
    }];
    
    //设置当前角色状态为被呼叫，（被发offer）
    //        _role = RoleCallee;
}
#pragma mark --answer
-(void)answerWith:(NSDictionary *)dic{
    NSDictionary *dataDic = dic[@"data"];
    if([dataDic count]==0){
        return;
    }
    NSString *sdp = dataDic[@"sdp"];
    
    NSString *socketId = dic[@"sender"];
    RTCPeerConnection *peerConnection = [_connectionDic objectForKey:socketId];
    RTCSessionDescription *remoteSdp = [[RTCSessionDescription alloc] initWithType:RTCSdpTypeAnswer sdp:sdp];
//    RTCSessionDescription *newSdp = [self descriptionForDescription:remoteSdp preferredVideoCodec:@"H264"];
    __weak RTCPeerConnection * weakPeerConnection = peerConnection;
    [peerConnection setRemoteDescription:remoteSdp completionHandler:^(NSError * _Nullable error) {
//                    [self setSessionDescriptionWithPeerConnection:weakPeerConnection];
    }];
}
#pragma mark WebSocketDelegate
- (void)webSocket:(SRWebSocket *)webSocket didReceiveMessage:(id)message{
    NSLog(@"收到服务器消息:%@",message);
    NSDictionary *dic = [NSJSONSerialization JSONObjectWithData:[message dataUsingEncoding:NSUTF8StringEncoding] options:NSJSONReadingMutableContainers error:nil];
    NSString *eventName = dic[@"event"];
    NSLog(@"====================eventName===============%@",eventName);
    
    //1.发送加入房间后的反馈
    if ([eventName isEqualToString:@"open"])
    {
        [self openWith:dic];
        
    }
    //4.接收到新加入的人发了ICE候选，（即经过ICEServer而获取到的地址）
    else if ([eventName isEqualToString:@"_ice_candidate"])
    {
        [self _ice_candidateWith:dic];
    }
    //2.其他新人加入房间的信息
    else if ([eventName isEqualToString:@"join"])
    {
        [self joinWith:dic];
        
    }
    //有人离开房间的事件
    else if ([eventName isEqualToString:@"remove"])
    {
        [self removeWith:dic];
        
    }
    //这个新加入的人发了个offer
    else if ([eventName isEqualToString:@"offer"])
    {
        [self offerWith:dic];
    }
    //回应offer
    else if ([eventName isEqualToString:@"answer"])
    {
        [self answerWith:dic];
    }
}

- (void)webSocketDidOpen:(SRWebSocket *)webSocket{
    NSLog(@"socket连接成功");
 
    dispatch_async(dispatch_get_main_queue(), ^{
        if ([self->_delegate respondsToSelector:@selector(webRTCHelper:socketConnectState:)]) {
            [self->_delegate webRTCHelper:self socketConnectState:WebSocketConnectSuccess];
        }
    });
}

- (void)webSocket:(SRWebSocket *)webSocket didFailWithError:(NSError *)error{
    NSLog(@"socket连接失败");
    dispatch_async(dispatch_get_main_queue(), ^{
        if ([self->_delegate respondsToSelector:@selector(webRTCHelper:socketConnectState:)]) {
            [self->_delegate webRTCHelper:self socketConnectState:WebSocketConnectSuccess];
        }
    });
}

- (void)webSocket:(SRWebSocket *)webSocket didCloseWithCode:(NSInteger)code reason:(NSString *)reason wasClean:(BOOL)wasClean{
    NSLog(@"socket关闭。code = %ld,reason = %@",code,reason);
    
}

- (NSString *)getKeyFromConnectionDic:(RTCPeerConnection *)peerConnection
{
    //find socketid by pc
    static NSString *socketId;
    [_connectionDic enumerateKeysAndObjectsUsingBlock:^(NSString *key, RTCPeerConnection *obj, BOOL * _Nonnull stop) {
        if ([obj isEqual:peerConnection])
        {
            NSLog(@"%@",key);
            socketId = key;
        }
    }];
    return socketId;
}

- (RTCSessionDescription *)descriptionForDescription:(RTCSessionDescription *)description preferredVideoCodec:(NSString *)codec
{
    NSString *sdpString = description.sdp;
    NSString *lineSeparator = @"\n";
    NSString *mLineSeparator = @" ";
    // Copied from PeerConnectionClient.java.
    // TODO(tkchin): Move this to a shared C++ file.
    NSMutableArray *lines =
    [NSMutableArray arrayWithArray:
     [sdpString componentsSeparatedByString:lineSeparator]];
    NSInteger mLineIndex = -1;
    NSString *codecRtpMap = nil;
    // a=rtpmap: /
    // [/]
    NSString *pattern =
    [NSString stringWithFormat:@"^a=rtpmap:(\\d+) %@(/\\d+)+[\r]?$", codec];
    NSRegularExpression *regex =
    [NSRegularExpression regularExpressionWithPattern:pattern
                                              options:0
                                                error:nil];
    for (NSInteger i = 0; (i < lines.count) && (mLineIndex == -1 || !codecRtpMap);
         ++i) {
        NSString *line = lines[i];
        if ([line hasPrefix:@"m=video"]) {
            mLineIndex = i;
            continue;
        }
        NSTextCheckingResult *codecMatches =
        [regex firstMatchInString:line
                          options:0
                            range:NSMakeRange(0, line.length)];
        if (codecMatches) {
            codecRtpMap =
            [line substringWithRange:[codecMatches rangeAtIndex:1]];
            continue;
        }
    }
    if (mLineIndex == -1) {
        RTCLog(@"No m=video line, so can't prefer %@", codec);
        return description;
    }
    if (!codecRtpMap) {
        RTCLog(@"No rtpmap for %@", codec);
        return description;
    }
    NSArray *origMLineParts =
    [lines[mLineIndex] componentsSeparatedByString:mLineSeparator];
    if (origMLineParts.count > 3) {
        NSMutableArray *newMLineParts =
        [NSMutableArray arrayWithCapacity:origMLineParts.count];
        NSInteger origPartIndex = 0;
        // Format is: m=    ...
        [newMLineParts addObject:origMLineParts[origPartIndex++]];
        [newMLineParts addObject:origMLineParts[origPartIndex++]];
        [newMLineParts addObject:origMLineParts[origPartIndex++]];
        [newMLineParts addObject:codecRtpMap];
        for (; origPartIndex < origMLineParts.count; ++origPartIndex) {
            if (![codecRtpMap isEqualToString:origMLineParts[origPartIndex]]) {
                [newMLineParts addObject:origMLineParts[origPartIndex]];
            }
        }
        NSString *newMLine =
        [newMLineParts componentsJoinedByString:mLineSeparator];
        [lines replaceObjectAtIndex:mLineIndex
                         withObject:newMLine];
    } else {
        RTCLogWarning(@"Wrong SDP media description format: %@", lines[mLineIndex]);
    }
    NSString *mangledSdpString = [lines componentsJoinedByString:lineSeparator];
    return [[RTCSessionDescription alloc] initWithType:description.type
                                                   sdp:mangledSdpString];
}

@end
  1. ChatViewController.h
#import 

@interface ChatViewController : UIViewController

@end
  1. ChatViewController.m
//
//  ChatViewController.m
//  WebRTC_new
//
//  Created by
//  Copyright © 2020年
//

#import "ChatViewController.h"
#import 
#import "WebRTCHelper.h"
#import 

#define kWidth [UIScreen mainScreen].bounds.size.width
#define kHeight [UIScreen mainScreen].bounds.size.height

@interface ChatCell:UICollectionViewCell
/*注释*/
@property (nonatomic,strong)  RTCEAGLVideoView *videoView;
/*注释*/
@property (nonatomic,strong) RTCVideoTrack *track;
/*注释*/
@property (nonatomic,strong) CALayer *baseLayer;
@end

@implementation ChatCell


- (instancetype)init
{
    self = [super init];
    if (self) {
        self.videoView = [[RTCEAGLVideoView alloc] initWithFrame:CGRectMake(0, 0, (kWidth-40)/3, (kWidth-40)/3 + 50)];
        [self.contentView addSubview:self.videoView];
    }
    return self;
}
- (instancetype)initWithFrame:(CGRect)frame{
    self = [super initWithFrame:frame];
    if (self) {
        self.contentView.layer.borderColor = [UIColor whiteColor].CGColor;
        self.contentView.layer.borderWidth = 1;
        self.videoView = [[RTCEAGLVideoView alloc] initWithFrame:CGRectMake(0, 0, (kWidth-40)/3, (kWidth-40)/3 + 50)];
    }
    return self;
}

- (void)setTrack:(RTCVideoTrack *)track{
    if (track != nil) {
        self.contentView.layer.mask = nil;
        [self.contentView addSubview:self.videoView];
        [track addRenderer:self.videoView];
    }else{
        self.contentView.layer.mask = nil;
        for (UIView * view in self.contentView.subviews) {
            [view removeFromSuperview];
        }
        [self setShaperLayer];
    }
}


-(void)setShaperLayer{
    //高亮状态下的imageView
    UIImageView * highlightImageView = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, 50, 50)];
    highlightImageView.center = self.contentView.center;
    highlightImageView.image = [UIImage imageNamed:@"voice_ highlight"];
    //默认状态下的imageView
    UIImageView * defaultImageView = [[UIImageView alloc] initWithFrame:CGRectMake(0, 0, 50, 50)];
    defaultImageView.image = [UIImage imageNamed:@"voice_default"];
    //先添加highlightImageView,在添加defaultImageview
    defaultImageView.center = self.contentView.center;
    [self.contentView addSubview:defaultImageView];
    [self.contentView addSubview:highlightImageView];
    self.baseLayer = nil;
    if (self.baseLayer == nil) {
        self.baseLayer = [CALayer layer];
        self.baseLayer.frame = highlightImageView.bounds;
    }
    
    //创建左边layer
    CAShapeLayer * leftLayer = [CAShapeLayer layer];
    leftLayer.fillColor = [UIColor greenColor].CGColor;
    leftLayer.position = CGPointMake(-25, 25);
    leftLayer.bounds = highlightImageView.bounds;
    leftLayer.path = [UIBezierPath bezierPathWithRect:CGRectMake(0, 0, 50,50)].CGPath;
    [self.baseLayer addSublayer:leftLayer];
    
    //左边动画
    CABasicAnimation * leftAnimation = [CABasicAnimation animationWithKeyPath:@"position"];
    leftAnimation.fromValue = [NSValue valueWithCGPoint:CGPointMake(-25, 25)];
    leftAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(5, 25)];
    leftAnimation.duration = 1.0;
    leftAnimation.repeatCount = MAXFLOAT;
    [leftLayer addAnimation:leftAnimation forKey:@"noVoiceLeftAnimation"];
    

    //创建右边layer
    CAShapeLayer * rightLayer = [CAShapeLayer layer];
//    rightLayer.strokeColor = [UIColor greenColor].CGColor;
    rightLayer.bounds = highlightImageView.bounds;
    rightLayer.position = CGPointMake(75, 25);
    rightLayer.fillColor = [UIColor greenColor].CGColor;
    rightLayer.path = [UIBezierPath bezierPathWithRect:CGRectMake(0, 0, 50, 50)].CGPath;
    [self.baseLayer addSublayer:rightLayer];
    //动画
    CABasicAnimation * rightAnimation = [CABasicAnimation animationWithKeyPath:@"position"];
    rightAnimation.duration = 1.0;
    rightAnimation.fromValue = [NSValue valueWithCGPoint:CGPointMake(75, 25)];
    rightAnimation.toValue = [NSValue valueWithCGPoint:CGPointMake(45, 25)];
    rightAnimation.repeatCount = MAXFLOAT;
    [rightLayer addAnimation:rightAnimation forKey:@"noVoiceRightAnimation"];
    
    
    highlightImageView.layer.mask = self.baseLayer;
    
    
}

@end


@interface ChatViewController ()
{
    RTCMediaStream * _localSteam;
    //判断是显示前摄像头还是显示后摄像头（yes为前摄像头。false为后摄像头）
    BOOL _usingFrontCamera;
    //是否显示我的视频流（默认为yes，显示；no为不显示）
    BOOL _usingCamera;
}
@property (weak, nonatomic) IBOutlet UICollectionView *collectionView;
/*保存远端视频流*/
@property (nonatomic,strong) NSMutableDictionary *videoTracks;
/*房间内其他用户*/
@property (nonatomic,strong) NSMutableArray *members;
//显示本地视频的view
@property (weak, nonatomic) IBOutlet RTCCameraPreviewView *localVideoView;

@end

@implementation ChatViewController

/*注释*/
- (NSMutableArray *)members
{
    if(!_members){
        _members = [NSMutableArray array];
    }
    return _members;
}

/*注释*/
- (NSMutableDictionary *)videoTracks
{
    if(!_videoTracks){
        _videoTracks = [NSMutableDictionary dictionary];
    }
    return _videoTracks;
}

- (void)viewDidLoad {
    [super viewDidLoad];
    _usingFrontCamera = YES;
    _usingCamera = YES;
    NSLog(@"uid = %@",[[[UIDevice currentDevice] identifierForVendor] UUIDString]);
    [WebRTCHelper shareInstance].delegate = self;
    [WebRTCHelper shareInstance].friendDelegate = self;
    
    UICollectionViewFlowLayout * layout = [[UICollectionViewFlowLayout alloc] init];
    layout.minimumLineSpacing = 10;
    layout.minimumInteritemSpacing = 10;
    layout.itemSize = CGSizeMake((kWidth-40)/3, (kWidth-40)/3+50);
    self.collectionView.collectionViewLayout = layout;
    self.collectionView.delegate = self;
    self.collectionView.dataSource = self;
    [self.collectionView registerClass:[ChatCell class] forCellWithReuseIdentifier:@"chatCell"];
    
    [self connect];
    //设置屏幕常亮
    [[UIApplication sharedApplication] setIdleTimerDisabled:YES];
    if ([self.navigationController respondsToSelector:@selector(interactivePopGestureRecognizer)]) {
        self.navigationController.interactivePopGestureRecognizer.enabled = NO;
    }
    self.navigationItem.hidesBackButton = YES;
}
-(void)viewWillDisappear:(BOOL)animated{
    [super viewWillDisappear:animated];
    if ([self.navigationController respondsToSelector:@selector(interactivePopGestureRecognizer)]) {
        self.navigationController.interactivePopGestureRecognizer.enabled = YES;
    }
}
#pragma mark -按钮点击操作
/**
 * 关闭按钮
 */
- (IBAction)closeChatBtnClick:(UIButton *)sender {
    [[WebRTCHelper shareInstance] exitRoom];
    [self.navigationController popViewControllerAnimated:YES];
}

/**
 * 摄像头转换（前后摄像头）
 */
- (IBAction)swithVideoBtnClick:(UIButton *)sender {
    _usingFrontCamera = !_usingFrontCamera;
    [[WebRTCHelper shareInstance] swichCamera:_usingFrontCamera];

}

/**
 * 语音是否开启
 */
- (IBAction)swichAudioBtnClick:(UIButton *)sender {
    [sender setImage:[UIImage imageNamed:@"audioOn"] forState:UIControlStateNormal];
}
/**
 是否显示本地摄像头
 */
- (IBAction)swichLocaolCameraBtnClick:(UIButton *)sender {
    _usingCamera = !_usingCamera;
//    [sender setImage:[UIImage imageNamed:_usingCamera?@"videoOn":@"videoOff"] forState:UIControlStateNormal];
//    [[WebRTCHelper shareInstance] showLocaolCamera:_usingCamera];
}

/**
 * 连接服务器
 */
-(void)connect{
    [[WebRTCHelper shareInstance] connectServer:@"172.27.104.54" port:@"9090/SocketServer"];
}

- (NSInteger)collectionView:(UICollectionView *)collectionView numberOfItemsInSection:(NSInteger)section{
    NSLog(@"self.members=====%@", self.members);
    return self.members.count;
}
- (UICollectionViewCell *)collectionView:(UICollectionView *)collectionView cellForItemAtIndexPath:(NSIndexPath *)indexPath{
    ChatCell * cell = [collectionView dequeueReusableCellWithReuseIdentifier:@"chatCell" forIndexPath:indexPath];
    NSString * userId = [self.members objectAtIndex:indexPath.item];
    RTCVideoTrack * track = [self.videoTracks objectForKey:userId];
    NSLog(@"%@==6666==%@",track,userId);
    cell.track = track;
    return cell;
}

#pragma mark -WebRTCHelperFrindDelegate
- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper gotFriendList:(NSArray *)friendList{
    [self.members removeAllObjects];
    [self.members addObjectsFromArray:friendList];
    [_collectionView reloadData];
}

- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper gotNewFriend:(NSString *)friendId{
    [self.members addObject:friendId];
    [_collectionView reloadData];
}

- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper removeFriend:(NSString *)friendId{
    [self.members removeObject:friendId];
    [_collectionView reloadData];
    if (self.members.count == 0) {
//        [[WebRTCHelper shareInstance] exitRoom];
//        [self.navigationController popViewControllerAnimated:YES];
    }
}

#pragma mark -WebRTCHelperDelegate
- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper receiveMessage:(NSString *)message{
    NSLog(@"messaga = %@",message);
    
}

/**
 * 旧版本获取本地视频流的代理，在这个代理里面会获取到RTCVideoTrack类，然后添加到RTCEAGLVideoView类型的localVideoView上面
 */
- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper setLocalStream:(RTCMediaStream *)steam userId:(NSString *)userId{
    if (steam) {
        _localSteam = steam;
        RTCVideoTrack * track = [_localSteam.videoTracks lastObject];
        [track addRenderer:self.localVideoView];
    }
    
}
/**
 * 新版获取本地视频流的方法
 * @param captureSession RTCCameraPreviewView类的参数，通过设置这个，就可以达到显示本地视频的功能
 */
- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper capturerSession:(AVCaptureSession *)captureSession{
    self.localVideoView.captureSession = captureSession;
    
}

/**
 * 获取远端视频流的方法，主要是获取到RTCVideoTrack类型的数据，然后保存起来，在刷新列表的时候，添加到对应item里面的RTCEAGLVideoView类型的view上面
 */
- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper addRemoteStream:(RTCMediaStream *)stream userId:(NSString *)userId{
    RTCVideoTrack * track = [stream.videoTracks lastObject];
    NSLog(@"track====%@",track);
    if (track != nil) {
        [self.videoTracks setObject:track forKey:userId];
    }
        [self.collectionView reloadData];
}
- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper closeWithUserId:(NSString *)userId{
    [self.videoTracks removeObjectForKey:userId];
    if (self.videoTracks.count >= self.members.count) {
        [self.collectionView reloadData];
    }
}

- (void)webRTCHelper:(WebRTCHelper *)webRTCHelper socketConnectState:(WebSocketConnectState)connectState{
    if (connectState == WebSocketConnectField) {
        HGAlertViewController * alert = [HGAlertViewController alertControllerWithTitle:@"提示" message:@"连接socket失败" preferredStyle:(UIAlertControllerStyleAlert)];
        alert.addAction(@"取消",^(UIAlertAction *alertAction){
            [[WebRTCHelper shareInstance] exitRoom];
            [self.navigationController popViewControllerAnimated:YES];
        }).addAction(@"确定",^(UIAlertAction *alertAction){
            [[WebRTCHelper shareInstance] exitRoom];
            [self.navigationController popViewControllerAnimated:YES];
        });
        [self presentViewController:alert animated:YES completion:nil];
    }
}
-(void)dealloc{
    NSLog(@"移除了");
    //取消设置屏幕常亮
    [[UIApplication sharedApplication] setIdleTimerDisabled:NO];
}

@end

你可能感兴趣的:(WebRTC -ios)

  • 【iOS】MVC设计模式 Magnetic_h iosmvc设计模式objective-c学习ui
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
  • UI学习——cell的复用和自定义cell Magnetic_h ui学习
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • ios GCD _Waiting_
    1.GCD任务和队列学习GCD之前，先来了解GCD中两个核心概念：任务和队列。任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。同步执行（sync）：同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等
  • iOS内存管理简单理解 烧烤有点辣
    什么是引用计数引用计数（ReferenceCount）是一个简单而有效的管理对象生命周期的方式。当我们创建一个新对象的时候，它的引用计数为1，当有一个新的指针指向这个对象时，我们将其引用计数加1，当某个指针不再指向这个对象是，我们将其引用计数减1，当对象的引用计数变为0时，说明这个对象不再被任何指针指向了，这个时候我们就可以将对象销毁，回收内存。由于引用计数简单有效，除了Objective-C和S
  • metaRTC8.0，一个全新架构的webRTC SDK库 metaRTC webrtc音视频
    概述metaRTC8.0是metaRTC开源以来架构变化最大的一个版本，是metaIPC3.0等高性能的基础。metaRTC8.0是一个全新架构版本，并非在metaRTC7.0版本上简单升级，在QOS/语音对讲/内存占用/视频文件录制读取等方面新增多个模块，在弱网对抗/语音对讲/内存优化等效果上有显著提升。metaRTC8.0在一年多的开发中进行了近200次迭代，metaRTC8.0社区版计划在2
  • metaRTC/webRTC QOS 方案与实践 metaRTC metaRTC解决方案webrtcqos
    概述质量服务(QOS/QualityofService)是指利用各种技术方案提高网络通信质量的技术，网络通信质量需要解决下面两个问题：网络问题：UDP/不稳定网络/弱网下的丢包/延时/乱序/抖动数据量问题：发送数据量超带宽负载和平滑发送拥塞控制是各种技术方案的数据基础，丢包恢复解决丢包问题，抗乱序抖动解决网络乱序抖动问题，流量控制解决平滑发送数据/数据超带宽负载/延时问题。拥塞控制(Congest
  • metaRTC5.0 API编程指南(一) metaRTC metaRTCc++c语言webrtc
    概述metaRTC5.0版本API进行了重构，本篇文章将介绍webrtc传输调用流程和例子。metaRTC5.0版本提供了C++和纯C两种接口。纯C接口YangPeerConnection头文件:include/yangrtc/YangPeerConnection.htypedefstruct{void*conn;YangAVInfo*avinfo;YangStreamConfigstreamco
  • Vue + Express实现一个表单提交 九旬大爷的梦
    最近在折腾一个cms系统，用的vue+express，但是就一个表单提交就弄了好久，记录一下。环境：Node10+前端：Vue服务端：Express依赖包：vueexpressaxiosexpress-formidableelement-ui（可选）前言：axiosget请求参数是：paramsaxiospost请求参数是：dataexpressget接受参数是req.queryexpresspo
  • iOS下拉放大效果 RobinZhao
    好多下拉放大的实现方式是在tableView上面添加一个view，同时更改tableView.contentInset，下拉时改变view的frame来实现。今天用另外一种方式实现，效果如下：加油.gif具体实现方法：通过tableViewCell结合xib来实现，具体代码如下HomeViewController.m代码#import"HomeViewController.h"#import"He
  • axios 请求封装 web Rookie 工作前端javascriptajax
    文章目录1.前言2.axios下载3.代码实现4.实际使用1.前言本文是对于axios的二次封装处理，axios是一个基于Promise的网络请求库，作用于node.js和浏览器中；本文对于axios中的封装着重于直接使用，如果想要学习axios相关知识可以先行离开，后续在对其进行完善2.axios下载npminstallaxios3.代码实现//request.tsimportaxios,{Ax
  • 函数可以返回数组吗？有哪3种返回方法呢？如代码种的func2、func3、func4都可以返回数组。func1为什么会报错呢？关于返回数组需要注意哪些呢？ 神笔馬良 java算法数据结构
    问题描述：根据下列代码回答下列问题。//Createdby黑马程序员.#include"iostream"usingnamespacestd;/**函数返回数组，就是返回指针，要注意：*-不可返回局部数组（在函数内创建的数组），如果要返回需要*-static修饰*-动态内存创建（new[]、delete[]）*-返回全局（在函数外创建的对象）**不推荐函数返回数组，因为要么手动delete、要么s
  • ios私钥证书(p12)导入失败，Windows OpenSSl 1.1.1 下载 书边事. 其他
    ios私钥证书(p12)导入失败如果你用的OpenSSL版本是v3那么恭喜你V3必然报这个错，解决办法将OpenSSL3降低成v1。WindowsOpenSSl1.1.1下载阿里云网盘下载地址：OpenSSLV1
  • 网上商城项目总结报告 WEB前端程序贵 前端
    网上商城项目总结报告1：掌握的知识通过网上商城这个实战项目的开发，不仅了解到了一个项目的业务逻辑，而且掌握了实现相关业务功能的方法。通过这个实战项目，了解到了模块化开发项目的基础结构的搭建，以及项目文件的管理方式。通过这个实战项目，运用封装的接口api文档实现了客户端服务器之间的交互知识。通过封装的axios实例对象与方法，向服务器请求数据，然后渲染页面。通过运用localStorage本地储存的
  • Linux dmesg命令：显示开机信息 fafadsj666 linux数据库数据挖掘机器学习大数据
    通过学习《Linux启动管理》一章可以知道，在系统启动过程中，内核还会进行一次系统检测（第一次是BIOS进行加测），但是检测的过程不是没有显示在屏幕上，就是会快速的在屏幕上一闪而过那么，如果开机时来不及查看相关信息，我们是否可以在开机后查看呢？答案是肯定的，使用dmesg命令就可以。无论是系统启动过程中，还是系统运行过程中，只要是内核产生的信息，都会被存储在系统缓冲区中，已经为大家精心准备了大数据
  • （小白入门）Windows环境下搭建React Native Android开发环境 码农老黑 前端ReactNative移动开发Androidstudio
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
  • 招银网络&大疆&元象一面 Redstone Monstrosity 前端面试
    1.请尽可能详细地说明，XHR、axios和fetch这三者的区别是什么？axios和fetch的底层实现是什么？axios拦截器是什么？axios提供了哪些配置或功能，是fetch和XHR中没有的？你的回答中不要写出示例代码。XHR、axios和fetch的区别XHR(XMLHttpRequest)历史：XHR是最早的AJAX技术，由微软在1999年引入，后来被标准化。兼容性：几乎所有现代浏览器
  • 思科路由器交换机密码破解过程详解 zhane_hao
    路由启动过程加电自检(POST)加载bootstrap代码检查配置寄存器寻找CiscoIOS加载CiscoIOS寻找配置文件加载配置文件若没有配置文件，进入Setup模式，进行初始化配置运行路由器操作系统查看命令•showversion：检查配置寄存器的值,硬件配置,IOS版本•showflash：检查Flash中的IOS,或是flash大小,使用情况(占用多少,剩下多少)•showstartup
  • 定制优化Nextcloud镜像 攻城狮_正
    Nextcloud是一款开源免费的私有云存储网盘项目，可以让你快速便捷地搭建一套属于自己或团队的云同步网盘，从而实现跨平台跨设备文件同步、共享、版本控制、团队协作等功能。它的客户端覆盖了Windows、Mac、Android、iOS、Linux等各种平台，也提供了网页端以及WebDAV接口，所以你几乎可以在各种设备上方便地访问你的云盘。Nextcloud基于PHP语言开发，可以使用Nginx+PH
  • iOS使用SDWebview加载图片失败？ AnderQZ
    今天调试遇到一个很无奈的问题，就是出现了image无法加载出来。最后才发现是图片使用了中文命名，真TM的坑！SDWebimage没办法识别中文，必须要encode才行！
  • Dev-C++头文件小Bug 蒟蒻pzjdsg666 bugc语言c++
    Dev-C++应该是大家最常用的C++软件了吧，但它有几个小Bug。1、“万能头”众所周知，“万能头”在官方比赛中不能使用（你要用没人拦着你~呵呵），但在Dev-C++可以使用。所以，我们可以省掉好多头文件！如下：#includeusingnamespacestd;2、C语言头文件在Dev-C++中，你竟然可以使用C语言头文件（惊不惊喜~意不意外~）如下：#include3、iostream竟然包
  • vue axios跨域访问相关问题 | axios默认发送‘application/x-www-form-urlencoded‘格式数据 | Content-Type is not allowed b 就是爱吃肉ro #Vue&uni-appaxiosajaxcors跨域vuex-www-form-url
    文章目录概述报错1Content-TypeisnotallowedbyAccess-Control-Allow-Headersinpreflightrespon报错2返回状态码500好久没更博客了,最近一直搞框架搞项目,好多问题也都没有记录下来…好吧,那从今天起来,继续开始保持记录的好习惯,先写一下在axios上踩下了这么多坑.概述通过以下两个报错,来介绍解决使用axios来进行网络请求中的遇到的
  • html ios 滚动条隐藏,CSS溢出滚动和隐藏滚动条（iOS） 社长从来不假装 htmlios滚动条隐藏
    6个答案:答案0:(得分：5)我只是玩了这个codepen(https://codepen.io/devstreak/pen/dMYgeO)，看来如果你为下面的所有三个属性设置background-color到transparent，滚动(在这个例子中)同时删除box-shadows)，根本看不到滚动条：#style-1::-webkit-scrollbar-track{//-webkit-box
  • vue axios 如何读取项目下的json文件 战族狼魂 前端vue.jsjsonjavascript
    在Vue项目中，使用axios读取本地的JSON文件可以通过将JSON文件放置在public目录中，然后通过axios发起请求读取。步骤：将JSON文件放置在public目录下：Vue项目中的public目录是静态资源目录，项目编译后这些文件可以通过URL直接访问。将你的JSON文件，比如data.json，放在public目录中。使用axios读取JSON文件：在你的Vue组件中，通过axios
  • WebRTC之LiveKit的基础入门使用（入门必看） tabzzz 前端webrtcweb3typescript
    LiveKit本文主要是讲解在Next13+中如何使用LiveKit来实现简单的音视频通话，想了解更多的还是要去官方文档去掌握更复杂、高级的使用方法。什么是LiveKitLiveKit是一个开源的实时通信平台，基于WebRTC，主要用于构建高质量的音视频通话、实时数据传输和互动应用。LiveKit除了方便以外的大优势就是它提供了丰富的API和SDK，支持多种平台，包括Web、iOS、Android
  • 2K价位的手机还有这些神仙功能，绿厂ColorOS系统yyds 机测女孩
    有一个有趣的现象，即使到了2021年，苹果手机在硬件技术上已经被安卓阵营大幅领先，但依然有大批的粉丝为了体验iOS趋之若鹜，可见用户对于手机系统的看重并不亚于参数配置。近年来，不少国产品牌的手机明显意识到了这一点，在堆砌参数的同时也非常重视系统的构建与优化，诸如华为、OPPO等手机品牌在整体系统体验大幅上升。就拿我手上的2k价位的OPPOA96来说，作为一款价格相当亲民的中端机型，其系统体验上却完
  • Cocos2d、Cocos2dx、Cocos Creator、Cocos Studio的区别 Thomas游戏圈
    一、Cocos2d和Cocos2dx的区别【开发语言】：Cocos2d是Object-C写的，Cocos2dx是C++写的，支持使用C++、Lua或Java进行开发。【运行平台】：Cocos2d只能在IOS下运行，Cocos2dx是跨平台的，适配iOS、Android、HTML5、Windows和Mac系统，功能侧重于原生移动平台。点击链接加入群聊【Unity/Cocos交流群】【国籍】：Coco
  • iOS GCD底层分析(2)--同步异步函数、死锁、GCD单例 冼同学
    前言上一篇文章iOSGCD底层分析（1）留下了四个问题，分别是：死锁底层是怎么样子产生的？如果是异步函数，线程是怎样子创建的？底层通过_dispatch_worker_thread2方法完成任务的回调执行，那么触发调用的位置在哪？单例的底层原理是什么？准备工作libdispatch.dylibiOSGCD底层分析（1）1.同步函数上一篇文章中分系同步函数时进入了_dispatch_sync_f_i
  • Qt框架在跨平台应用开发中的优势 NewmanEdwarda2 qt开发语言
    随着软件技术的不断发展，跨平台应用开发已成为软件开发领域的一个重要趋势。在众多跨平台开发框架中，Qt因其强大的功能和灵活性而备受开发者的青睐。本文将从多个方面详细探讨Qt框架在跨平台应用开发中的优势。一、跨平台兼容性Qt框架最显著的优势之一就是其卓越的跨平台兼容性。Qt支持多种操作系统，包括Windows、Linux、macOS、Android、iOS等，使得开发者能够使用同一套代码库为不同平台开
  • uni-app开发微信小程序 hong161688 uni-app微信小程序小程序
    uni-app是一个使用Vue.js开发所有前端应用的框架，它支持编译到iOS、Android、H5、以及各种小程序（微信/支付宝/百度/字节跳动/QQ/京东等）平台。使用uni-app开发微信小程序，可以充分利用Vue.js的开发效率和小程序平台的原生能力，实现跨平台的高效开发。以下将详细介绍使用uni-app开发微信小程序的全过程，包括项目搭建、开发、调试、测试及发布等环节，内容将尽量达到或超
  • LeetCode[位运算] - #137 Single Number II Cwind javaAlgorithmLeetCode题解位运算
    原题链接：#137 Single Number II  要求： 给定一个整型数组，其中除了一个元素之外，每个元素都出现三次。找出这个元素 注意：算法的时间复杂度应为O(n)，最好不使用额外的内存空间   难度：中等   分析： 与#136类似，都是考察位运算。不过出现两次的可以使用异或运算的特性 n XOR n = 0, n XOR 0 = n，即某一
  • 《JavaScript语言精粹》笔记 aijuans JavaScript
    0、JavaScript的简单数据类型包括数字、字符创、布尔值（true/false）、null和undefined值，其它值都是对象。 1、JavaScript只有一个数字类型，它在内部被表示为64位的浮点数。没有分离出整数，所以1和1.0的值相同。 2、NaN是一个数值，表示一个不能产生正常结果的运算结果。NaN不等于任何值，包括它本身。可以用函数isNaN(number)检测NaN,但是
  • 你应该更新的Java知识之常用程序库 Kai_Ge java
    在很多人眼中，Java 已经是一门垂垂老矣的语言，但并不妨碍 Java 世界依然在前进。如果你曾离开 Java，云游于其它世界，或是每日只在遗留代码中挣扎，或许是时候抬起头，看看老 Java 中的新东西。 Guava Guava[gwɑ:və]，一句话，只要你做Java项目，就应该用Guava（Github）。 guava 是 Google 出品的一套 Java 核心库，在我看来，它甚至应该
  • HttpClient 120153216 httpclient
    /** * 可以传对象的请求转发，对象已流形式放入HTTP中 */ public static Object doPost(Map<String,Object> parmMap,String url) { Object object = null; HttpClient hc = new HttpClient(); String fullURL
  • Django model字段类型清单 2002wmj django
    Django 通过 models 实现数据库的创建、修改、删除等操作，本文为模型中一般常用的类型的清单，便于查询和使用： AutoField：一个自动递增的整型字段，添加记录时它会自动增长。你通常不需要直接使用这个字段；如果你不指定主键的话，系统会自动添加一个主键字段到你的model。(参阅自动主键字段) BooleanField：布尔字段,管理工具里会自动将其描述为checkbox。 Cha
  • 在SQLSERVER中查找消耗CPU最多的SQL 357029540 SQL Server
    返回消耗CPU数目最多的10条语句 SELECT TOP 10    total_worker_time/execution_count AS avg_cpu_cost, plan_handle,    execution_count,    (SELECT SUBSTRING(text, statement_start_of
  • Myeclipse项目无法部署，Undefined exploded archive location 7454103 eclipseMyEclipse
    做个备忘！ 错误信息为：       Undefined exploded archive location 原因：           在工程转移过程中，导致工程的配置文件出错； 解决方法：    
  • GMT时间格式转换 adminjun GMT时间转换
    普通的时间转换问题我这里就不再罗嗦了，我想大家应该都会那种低级的转换问题吧，现在我向大家总结一下如何转换GMT时间格式，这种格式的转换方法网上还不是很多，所以有必要总结一下，也算给有需要的朋友一个小小的帮助啦。 1、可以使用 SimpleDateFormat SimpleDateFormat    EEE-三位星期 d-天 MMM-月 yyyy-四位年
  • Oracle数据库新装连接串问题 aijuans oracle数据库
    割接新装了数据库，客户端登陆无问题，apache/cgi-bin程序有问题，sqlnet.log日志如下： Fatal NI connect error 12170.   VERSION INFORMATION:         TNS for Linux: Version 10.2.0.4.0 - Product
  • 回顾java数组复制 ayaoxinchao java数组
    在写这篇文章之前，也看了一些别人写的，基本上都是大同小异。文章是对java数组复制基础知识的回顾，算是作为学习笔记，供以后自己翻阅。首先，简单想一下这个问题：为什么要复制数组？我的个人理解：在我们在利用一个数组时，在每一次使用，我们都希望它的值是初始值。这时我们就要对数组进行复制，以达到原始数组值的安全性。java数组复制大致分为3种方式：①for循环方式 ②clone方式 ③arrayCopy方
  • java web会话监听并使用spring注入 bewithme Java Web
            在java web应用中，当你想在建立会话或移除会话时，让系统做某些事情，比如说，统计在线用户，每当有用户登录时，或退出时，那么可以用下面这个监听器来监听。        import java.util.ArrayList; import java.ut
  • NoSQL数据库之Redis数据库管理(Redis的常用命令及高级应用) bijian1013 redis数据库NoSQL
    一 .Redis常用命令         Redis提供了丰富的命令对数据库和各种数据库类型进行操作，这些命令可以在Linux终端使用。         a.键值相关命令         b.服务器相关命令 1.键值相关命令       &
  • java枚举序列化问题 bingyingao java枚举序列化
    对象在网络中传输离不开序列化和反序列化。而如果序列化的对象中有枚举值就要特别注意一些发布兼容问题: 1.加一个枚举值 新机器代码读分布式缓存中老对象，没有问题，不会抛异常。 老机器代码读分布式缓存中新对像，反序列化会中断，所以在所有机器发布完成之前要避免出现新对象，或者提前让老机器拥有新增枚举的jar。 2.删一个枚举值 新机器代码读分布式缓存中老对象，反序列
  • 【Spark七十八】Spark Kyro序列化 bit1129 spark
    当使用SparkContext的saveAsObjectFile方法将对象序列化到文件，以及通过objectFile方法将对象从文件反序列出来的时候，Spark默认使用Java的序列化以及反序列化机制，通常情况下，这种序列化机制是很低效的，Spark支持使用Kyro作为对象的序列化和反序列化机制，序列化的速度比java更快，但是使用Kyro时要注意，Kyro目前还是有些bug。 Spark
  • Hybridizing OO and Functional Design bookjovi erlanghaskell
      推荐博文： Tell Above, and Ask Below - Hybridizing OO and Functional Design 文章中把OO和FP讲的深入透彻，里面把smalltalk和haskell作为典型的两种编程范式代表语言，此点本人极为同意，smalltalk可以说是最能体现OO设计的面向对象语言，smalltalk的作者Alan kay也是OO的最早先驱，
  • Java-Collections Framework学习与总结-HashMap BrokenDreams Collections
            开发中常常会用到这样一种数据结构，根据一个关键字，找到所需的信息。这个过程有点像查字典，拿到一个key，去字典表中查找对应的value。Java1.0版本提供了这样的类java.util.Dictionary(抽象类)，基本上支持字典表的操作。后来引入了Map接口，更好的描述的这种数据结构。  &nb
  • 读《研磨设计模式》-代码笔记-职责链模式-Chain Of Responsibility bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /** * 业务逻辑：项目经理只能处理500以下的费用申请，部门经理是1000，总经理不设限。简单起见，只同意“Tom”的申请 * bylijinnan */ abstract class Handler { /*
  • Android中启动外部程序 cherishLC android
    1、启动外部程序 引用自： http://blog.csdn.net/linxcool/article/details/7692374 //方法一 Intent intent=new Intent(); //包名 包名+类名（全路径） intent.setClassName("com.linxcool", "com.linxcool.PlaneActi
  • summary_keep_rate coollyj SUM
    BEGIN /*DECLARE minDate varchar(20) ; DECLARE maxDate varchar(20) ;*/ DECLARE stkDate varchar(20) ; DECLARE done int default -1; /* 游标中 注册服务器地址 */ DE
  • hadoop hdfs 添加数据目录出错 daizj hadoophdfs扩容
    由于原来配置的hadoop data目录快要用满了，故准备修改配置文件增加数据目录，以便扩容，但由于疏忽，把core-site.xml, hdfs-site.xml配置文件dfs.datanode.data.dir 配置项增加了配置目录，但未创建实际目录，重启datanode服务时，报如下错误： 2014-11-18 08:51:39,128 WARN org.apache.hadoop.h
  • grep 目录级联查找 dongwei_6688 grep
           在Mac或者Linux下使用grep进行文件内容查找时，如果给定的目标搜索路径是当前目录，那么它默认只搜索当前目录下的文件，而不会搜索其下面子目录中的文件内容，如果想级联搜索下级目录，需要使用一个“-r”参数： grep -n -r "GET" .   上面的命令将会找出当前目录“.”及当前目录中所有下级目录
  • yii 修改模块使用的布局文件 dcj3sjt126com yiilayouts
    方法一：yii模块默认使用系统当前的主题布局文件，如果在主配置文件中配置了主题比如: 'theme'=>'mythm', 那么yii的模块就使用 protected/themes/mythm/views/layouts 下的布局文件； 如果未配置主题，那么 yii的模块就使用  protected/views/layouts 下的布局文件， 总之默认不是使用自身目录 pr
  • 设计模式之单例模式 come_for_dream 设计模式单例模式懒汉式饿汉式双重检验锁失败无序写入
                    今天该来的面试还没来，这个店估计不会来电话了，安静下来写写博客也不错，没事翻了翻小易哥的博客甚至与大牛们之间的差距，基础知识不扎实建起来的楼再高也只能是危楼罢了，陈下心回归基础把以前学过的东西总结一下。   *********************************
  • 8、数组 豆豆咖啡 二维数组数组一维数组
      一、概念       数组是同一种类型数据的集合。其实数组就是一个容器。   二、好处       可以自动给数组中的元素从0开始编号，方便操作这些元素   三、格式   //一维数组 1,元素类型[] 变量名 = new 元素类型[元素的个数] int[] arr =
  • Decode Ways hcx2013 decode
    A message containing letters from A-Z is being encoded to numbers using the following mapping: 'A' -> 1 'B' -> 2 ... 'Z' -> 26 Given an encoded message containing digits, det
  • Spring4.1新特性——异步调度和事件机制的异常处理 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • squid3(高命中率)缓存服务器配置 liyonghui160com
        系统:centos 5.x   需要的软件:squid-3.0.STABLE25.tar.gz 1.下载squid wget http://www.squid-cache.org/Versions/v3/3.0/squid-3.0.STABLE25.tar.gz tar zxf squid-3.0.STABLE25.tar.gz &&
  • 避免Java应用中NullPointerException的技巧和最佳实践 pda158 java
    1) 从已知的String对象中调用equals()和equalsIgnoreCase()方法，而非未知对象。 　　总是从已知的非空String对象中调用equals()方法。因为equals()方法是对称的，调用a.equals(b)和调用b.equals(a)是完全相同的，这也是为什么程序员对于对象a和b这么不上心。如果调用者是空指针，这种调用可能导致一个空指针异常 Object unk
  • 如何在Swift语言中创建http请求 shoothao httpswift
    概述：本文通过实例从同步和异步两种方式上回答了”如何在Swift语言中创建http请求“的问题。 如果你对Objective-C比较了解的话，对于如何创建http请求你一定驾轻就熟了，而新语言Swift与其相比只有语法上的区别。但是，对才接触到这个崭新平台的初学者来说，他们仍然想知道“如何在Swift语言中创建http请求？”。 在这里,我将作出一些建议来回答上述问题。常见的
  • Spring事务的传播方式 uule spring事务
    传播方式：        新建事务       required       required_new   - 挂起当前         非事务方式运行       supports   &nbs
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他