A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

Pisces_Tiger

  • 黑马币:59

  • 帖子:43

  • 精华:0

© Pisces_Tiger   /  2017-4-3 21:34  /  3631 人查看  /  57 人回复  /   6 人收藏 转载请遵从CC协议 禁止商业使用本文

TCP的服务端
      服务端  java.net.ServerSocket
               ServerSocket(int port) 创建服务端对象
    方法
              Socket accept() 获取连接服务端的Socket对象
   
   1.创建ServerSocket对象
   2.调用accept获取连接服务端的客户端对象
   3.调用Socket的获取字节输入流的方法接收你好
   4.调用Socket的获取字节输出流的方法发送不好
5.关闭资源
ServerSocket server= newServerSocket(8888);
        Socketclient = server.accept();
        
        InputStreamin = client.getInputStream();
//在服务器创建新的文件名
        String fileName ="com.itheima" + System.currentTimeMillis() + newRandom().nextInt(9999)+".txt";
        BufferedOutputStreambos = new BufferedOutputStream(new FileOutputStream(new File("e:\\project",fileName)));
        byte[] buf = new byte[1024];
        int len = -1;
   
        while((len = in.read(buf)) != -1){
            bos.write(buf, 0, len);
        }
        //接收完成后给客户端发送提示
        OutputStreamout = client.getOutputStream();
        out.write("接收完毕".getBytes());
        
        out.close();
        bos.close();
        in.close();
        client.close();
TCP客户端
   客户端  java.net.Socket
     构造方法
                 Socket(InetAddress address, int port)
                 Socket(String host, int port)  创建客户端对象 绑定服务端ip地址及端口号
   方法
                InputStream getInputStream() 获取输入流
                OutputStream getOutputStream() 获取输出流
   
   
   1.创建客户端对象绑定服务端的ip和端口
   2.获取输出流 输出"你好"
   3.获取输入流 用来接收服务端发送的"不好"
   4.关闭资源
Socket client= newSocket("127.0.0.1",8888);
        
        OutputStreamout = client.getOutputStream();
        BufferedInputStreambis = new BufferedInputStream(new FileInputStream("e:\\project\\socket.txt"));
        
        byte[] buf = new byte[1024];
        int len = -1;
        
        while((len = bis.read(buf)) != -1){
            out.write(buf, 0, len);
        }
        //告知服务器发送完毕 必须有
        client.shutdownOutput();
        //接收服务端的提示
        InputStreamin = client.getInputStream();
        len = in.read(buf);
        System.out.println("接收到的data"+new String(buf,0,len));
        
        in.close();
        bis.close();
        
        out.close();
    client.close();



回复 使用道具 举报
文件上传多线程版本, 服务器端
ServerSocket server = new ServerSocket(8888);
        final Socket client = server.accept();
        while(true){
            new Thread(){
                public void run(){
                    InputStream in = null;
                    BufferedOutputStream bos = null;
                    OutputStream out = null;
                    try {
                        in = client.getInputStream();
                        String fileName = "com.itheima"+System.currentTimeMillis()+new Random().nextInt(9999)+".txt";
                        bos = new BufferedOutputStream(new FileOutputStream(new File("e:\\project",fileName)));

                        byte[] buf = new byte[1024];
                        int len = -1;
                        while((len = in.read(buf)) != -1){
                            bos.write(buf, 0, len);
                        }

                        out = client.getOutputStream();
                        out.write("接收ok".getBytes());
                    } catch (IOException e) {
                        e.printStackTrace();
                    }finally{
                        try {
                            if(out != null){
                                out.close();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        try {
                            if(bos != null){
                                bos.close();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        try {
                            if(in != null){
                                in.close();
                            }

                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        try {
                            if(client != null){
                                client.close();
                            }
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                }

            }.start();
        }

回复 使用道具 举报
定义一个类 类具备 私有成员变量  空参数构造方法 get/set方法 //实现Serializable接口 我们称这样的类叫做 JavaBean
获取字节码文件对象
   1.Object类中的方法  
        Class getClass() 获取字节码文件对象
   2.每种数据类型 都有一个静态的class属性 包括基本数据类型
   3.Class类的静态方法
       staticClass forName(String className)
Person p = new Person();
        Classc = p.getClass();
        
        Classc2 = Person.class;
        
        Class c3 = Class.forName("com.itheima.bean.Person");

反射获取构造方法
        Class类中方法
           Constructor<?>[]getConstructors()  返回当前字节码文件对象的所有public修饰的构造方法
           Constructor<T>getConstructor(Class<?>... parameterTypes) 返回指定了参数的构造方法
           参数
              Constructor 用来描述构造方法的类  返回回来的就是Constructor的对象
              Class<?>...parameterTypes 可变参数  是构造方法参数类型 如果参数不写 则返回空参构造方法
       Constructor
            T newInstance(Object... initargs)  运行构造方法创建对象
                             返回值T 是泛型 没有泛型就是Object类型
                             参数 为构造方法要使用的实际参数  参数不写则运行的是空参构造方法
Constructor con = c.getConstructor();
        Objectobj= con.newInstance();
        
        Constructorcon2 = c.getConstructor(String.class,int.class);
        Objectobj2= con2.newInstance("Lily",18);
//      getDeclaredConstructor获取私有构造函数
        Constructorcon3 = c.getDeclaredConstructor(String.class);
//      允许暴力访问
        con3.setAccessible(true);
        Objectobj3= con3.newInstance("Jim");

反射获取成员变量(因为成员变量都是私有的,所以用的很少)(了解)
       Class类中方法
            FieldgetField(String name)   返回指定变量名的成员变量
            Field[] getFields()  返回所有public修饰的成员变量
       Field类中的方法
            void set(Objectobj, Object value) 为指定对象的成员变量赋值  obj为要赋值的对象 value为要赋的值
       1.获取字节码文件对象
       2.通过字节码文件对象获取字段对象
       3.调用set方法为字段赋值 注意 需要给定一个对象 可以通过快捷方式反射创建
Field[] fields = c.getDeclaredFields();
        for(Field field : fields){
            System.out.println(field);
        }
//      获取私有字段
        FieldnameField = c.getDeclaredField("name");
        FieldageField = c.getDeclaredField("age");
//      允许暴力访问
        nameField.setAccessible(true);
        ageField.setAccessible(true);
//      设置字段值
        nameField.set(obj, "Tom");
        ageField.set(obj, 18);
//      获取字段值
        System.out.println(nameField.get(obj));
        System.out.println(ageField.get(obj));
//      System.out.println(obj);



回复 使用道具 举报
反射获取成员方法
       Class类中方法
            Method[] getMethods()  获取所有公共方法
            Method getMethod(String name, Class<?>... parameterTypes)  获取指定方法名的公共方法
                                       name 方法名
                                       Class<?>... parameterTypes 可变参 方法需要的参数类型 如果不写为空参方法
       Method类中方法
            Object invoke(Object obj, Object... args)   对带有指定参数的指定对象调用由此 Method 所表示的方法
                                 obj 要运行哪个对象的方法
                                 args 方法的实际参数
       1.获取字节码文件对象
       2.通过字节码文件对象获取方法对象
       3.调用invoke方法运行当前方法 注意 需要给定一个对象 可以通过快捷方式反射创建
Method setMethod = c.getMethod("setName", String.class);
        setMethod.invoke(obj, "Jim");
      
        Method setMethod2 = c.getMethod("setAge", int.class);
        setMethod2.invoke(obj, 18);

Object obj = c.newInstance();
      
        FileReader fr = new FileReader("prop.properties");
        Properties p = new Properties();
        p.load(fr);
      
        Set<String> keys = p.stringPropertyNames();
        for(String key : keys){
            String methodName = "set" + key.substring(0, 1).toUpperCase() + key.substring(1);
            Method setMethod = c.getMethod(methodName, String.class);
            setMethod.invoke(obj, p.getProperty(key));
        }

回复 使用道具 举报
单元测试
         @Testeclipse自带jar Ctrl+1导入使用
注解
         JDK提供的注解
                   @Deprecated表示被修饰的方法已经过时
                   @Override重写方法 1.5支持父类不支持接口 1.5之后支持接口
                   @SuppressWarnings抑制警告 需要给属性值 all 所有警告都抑制
自定义注解
                   关键字@interface
                  成员
                            publicabstract 返回值类型属性名()[defualt 属性值];
                            返回值类型
                                     基本类型,字符串,Class,注解,枚举,一维数组
public @interface Annotation {
  public abstract intage();
  public abstract String name();
}
注意:需要加上元注解才可以使用(不需要背单词能够使用快捷键写出即可)
                         @Retention 用于确定被修饰的自定义注解生命周期
                                      RetentionPolicy.SOURCE 被修饰的注解只能存在源码中,字节码class没有。用途:提供给编译器使用。
                                     RetentionPolicy.CLASS被修饰的注解只能存在源码和字节码中,运行时内存中没有。用途:JVM java虚拟机使用
                                     RetentionPolicy.RUNTIME被修饰的注解存在源码、字节码、内存(运行时)。用途:取代xml配置
                         @Target 用于确定被修饰的自定义注解使用位置
                                     ElementType.TYPE修饰类、接口
                                     ElementType.CONSTRUCTOR  修饰构造
                                     ElementType.METHOD修饰方法
                                     ElementType.FIELD修饰字段
//自定义注解要做元注解声明 Retention 生命周期  Target注解作用的位置
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface Annotation02 {
    public abstract int age(); //default 10;
    public abstract String name(); //default "Lily";
    public abstract Annotation AnnotationDemo() default @Annotation(age=19,name="hellp");
    public abstract String[] names() default {"JIm","Tom"};
   
}
       注解使用
                   使用格式
                            @注解类名( 属性名= , 属性名 = , .....)
                            应用在类,方法,构造方法 字段上
                   注意
                            如果属性名为value,且当前只有一个属性,value可以省略。
                            如果属性类型为数组,设置内容格式为:{ 1,2,3 }
                            一个对象上,注解只能使用一次,不能重复使用。
         解析
                            java.lang.reflect.AnnotatedElement
                            booleanisAnnotationPresent(Class annotationClass) 当前对象是否有注解 传入判断注解的字节码文件对象
                            TgetAnnotation(Class<T> annotationClass) 获得当前对象上指定的注解 传入获取注解的字节码文件对象 返回要获取的注解类型
public classAnnotationTest {
    @Annotation02(age = 30,name = "hello")
    public void method(){
        System.out.println("此方法被Annotaion02注解");
    }
    @Test
    public void method2(){
        
        Classc = AnnotationTest.class;
        Method[]methods = c.getMethods();
        
        for(Method method : methods){
            boolean b = method.isAnnotationPresent(Annotation02.class);
//          System.out.println(method.getName());
            if(b){
                System.out.println(method.getName());
//              获取方法上注解的实例
Annotation02 anno = (Annotation02) method.getAnnotation(Annotation02.class);
//              输出注解中携带的信息
                System.out.println(anno.name());
            }
        }

回复 使用道具 举报
类加载器
         全盘负责委托机制
                   全盘负责:A类如果要使用B类(不存在),A类加载器C必须负责加载B
                   委托机制:A类加载器如果要加载资源B,必须询问父类加载是否加载。
         获取类加载器
                   ClassLoaderloader = 类名.class.getClassLoader();
动态代理
         调用者------
         调用者-----代理类-----
         ObjectproxyObj = Proxy.newProxyInstance(参数1,参数2,参数3);
                   参数1ClassLoader,负责将动态创建类,加载到内存。当前类.class.getClassLoader();
                   参数2Class[] interfaces,代理类需要实现的所有接口(确定方法),被代理类实例.getClass().getInterfaces();
                   参数3InvocationHandler,请求处理类,代理类不具有任何功能,代理类的每一个方法执行时,调用处理类invoke方法。
                          invoke(Object proxy ,Method ,Object[]args)
                                     参数1:代理实例 与你无关
                                     参数2:当前执行的方法
                                     参数3:方法实际参数。
public class ProxyDemo{
//  传入被代理的对象  匿名对象使用obj  final修饰  
//  返回值object 生成的代理对象
    public Object getProxy(final Object obj){
//     被代理对象的类加载器   被代理对象实现的接口   要实现的InvocationHandler子类
        ObjectnewProxy = (Object)Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),newInvocationHandler(){
            @Override
//           返回值Object method执行后的返回结果
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Classc = obj.getClass();
                Method[]methods = c.getMethods();
               
                if("add".equals(method.getName())){
                    System.out.println("执行add");   
                }
                if("remove".equals(method.getName())){
                    System.out.println("执行remove");
                }
                if("get".equals(method.getName())){
                    System.out.println("执行get");
                }
                return method.invoke(obj, args);
            }
        });
        return newProxy;
    }      
}
测试:
public classProxyTest {
    public static void main(String[] args){
        ProxyDemoproxy = new ProxyDemo();
        List<String>list = newArrayList<String>();
        list = (List<String>)proxy.getProxy(list);
        list.add("hello");
        list.add("world");
        
        list.get(0);
    }
}

回复 使用道具 举报
Xsl全名:xml schema instance
Web-app web.xml的根节点标签名称
Version 版本
Xmlns web.xml文件用到的命名空间
Xmlnsxsi  web.xml遵守xml规范
XsishemaLocation 具体用到的schema资源
XML
         可扩展的标记语言
         作用
                   1.存放数据
                   2.配置文件
         语法
                   文档声明
                            <?xmlversion="1.0" encoding="UTF-8"?>
                            1.文档声明必须为<?xml开头,以?>结束;
                            2.文档声明必须从文档的00列位置开始;
                            3.文档声明只有2个属性:
                                     version版本
                                     encoding编码
                   元素
                            <bean></bean>
                            1.必须开始结束
                            2.标签由开始标签,元素体、结束标签组成<hello>大家好</hello>
                            3.元素体 可以是文本 也可以是标签<b><a>你好</a></b>
                            4.空元素<c   />
                            5.元素命名 区分大小写 不用特殊符号 不要xml开头
                            6.必须有根元素
                   属性
                            <beanid=”” className=””>
                            1.出现在开始标签
                            2.属性名="属性值"
                            3.一个元素多个属性不可相同
                            4.属性名无特殊符号 字母开头
                   注释
                            <!---->
                   转义字符(不用记)
                            <  &lt;
                            >  &gt;
                            "  &quot;
                            '  &apos;
                            &  &amp;
                   CDATA
                            <![CDATA[
                                     纯文本
                            ]]>
                   DTD
                            引用DTD
                                     本地dtd
                                     <!DOCTYPEbeans SYSTEM "bean.dtd">
                                     公共dtd
                                     <!DOCTYPEbeans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
                                     "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
                            元素声明(了解)
                                     0-1
                                     *  任意次
                                     +  至少1
                                     ()分组
                                     |  
                                     ,  顺序
                            属性声明(了解)
                                     属性的语法:(attribute
                                     <!ATTLIST元素名
                                               属性名 属性类型 约束
                                               属性名 属性类型 约束
                                               ...
                                     >
                                     元素名:属性必须是给元素添加,所有必须先确定元素名
                                     属性名:自定义
                                     属性类型:IDCDATA、枚举…
                                               ID: ID类型的属性用来标识元素的唯一性
                                               CDATA:文本类型
         
                                     约束:
                                               #REQUIRED:说明属性是必须的;required
                                               #IMPLIED:说明属性是可选的;implied
                            能根据约束写标签即可
                   Schema
                            引用Schema
                                     <beansxmlns="http://www.itcast.cn/bean"
                                           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                                            xsi:schemaLocation="http://www.itcast.cn/beanbean-schema.xsd"
                                     ></bean>
                            能根据约束写标签即可
                           
                           
      xml解析
                   DOM解析原理
                            xml加载进内存 形成DOM 并得到一个document对象
                   dom4j
                            常用API如下:
                            1.SaxReader对象
                                     a)read() 加载执行xml文档
                            2.Document对象
                                     a)getRootElement()获得根元素
                            3.Element对象
                                     a)elements() 获得指定名称的所有子元素。可以不指定名称
                                     b)element() 获得指定名称第一个子元素。
                                     c)getName()获得当前元素的元素名
                                     d)attributeValue() 获得指定属性名的属性值
                                     e)elementText() 获得指定名称子元素的文本值 不实用
                                     f)getText()获得当前元素的文本内容

回复 使用道具 举报
收藏了,以前学的都忘得差不多了,连配环境变量都忘了...
回复 使用道具 举报
回复回复
回复 使用道具 举报
顶顶顶顶顶顶顶顶
回复 使用道具 举报
加油,谢谢分享
回复 使用道具 举报
- - 6666666666666666
回复 使用道具 举报
都在这里晒笔记啊  牛
回复 使用道具 举报
貌似是从JavaSE开始的啊。加油。
回复 使用道具 举报
多交流,更有利于学习,...
回复 使用道具 举报
MosLY 版主 2017-5-29 00:10:16
56#
厉害了,我的哥...
回复 使用道具 举报
BeanUtils
                   setProperty(Objectobj,String name,Object value)
                            Student stu = new Student();
                            BeanUtils.setProperty(stu, "name", "Lily");
                            BeanUtils.setProperty(stu, "age", 18);
                            System.out.println(stu);
getProperty(Object obj,String name)
                            Studentstu = new Student("Lilei",20);
                            Stringname = BeanUtils.getProperty(stu, "name");
                            Stringage = BeanUtils.getProperty(stu, "age");
                            System.out.println(name);
                            System.out.println(age);
populate(Object bean, Map<String,String[]> properties)
                            Student stu = new Student();
                            Map<String,String[]>map = new HashMap();
                            map.put("name", new String[]{"Jim"});
                            map.put("age", new String[]{"18"});      
                            BeanUtils.populate(stu, map);
System.out.println(stu);
饥饿单例模式
         private static final Singleton01 single = new Singleton01();
                   private Singleton01(){
                  
                   }
                   publicstatic Singleton01 getSingle(){
                            returnsingle;
                   }
懒汉单例模式
private static SingletonDemo02 single;
                   private SingletonDemo02(){
                  
                   }
                   public static  SingletonDemo02getSingle(){
//                         如果创建 就不在进入同步代码块 提高效率
                            if(single == null){
                                     synchronized(SingletonDemo02.class){
//                                           避免同步时创建多个对象
                                               if(single == null){
                                               single = new SingletonDemo02();
                                               }
                                     }
                            }
                            return single;
                   }

回复 使用道具 举报
123
您需要登录后才可以回帖 登录 | 加入黑马