准图灵奖得主
准图灵奖得主

JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解

JavaSE回顾——Junit单元测试&反射&注解

  • 1. JavaWeb课程介绍
      • 一、为什么要学习JavaWeb?
      • 二、适用人群
      • 三、课程安排
      • 四、后期学习路径
  • 2. Java SE 内容补充
      • 2.1 Junit单元测试
        • 测试分类∶
        • Junit使用∶
          • 在main方法里的测试
          • Junit单元测试(白盒测试)
      • 2.2 反射
        • 获取class对象的方式
        • class对象功能∶
          • 获取成员变量
          • 获取构造方法
          • 获取成员方法 & 获取类名
        • 反射案例
      • 2.3 注解
        • 注解概述
        • 注释javadoc演示
        • JDK中预定义的一些注解
        • 自定义注解
          • 语法格式
          • 注解中的属性
          • 元注解
        • 使用(解析)注解
        • 注解使用案例
        • 小结:

说明：本内容整理自黑马程序员B站Java web视频>>黑马程序员B站Java web视频

1. JavaWeb课程介绍

一、为什么要学习JavaWeb?

  • 学习目的： 获得现在主流开发技术
  • Javaweb是什么: 使用Java语言完成服务器端程序开发

JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第1张图片

二、适用人群

  • 有一定的Java基础知识
    • 基础语法
    • 面向对象思想
    • JDK常用API:字符串、集合、IO
    • 网络编程
  • 热爰编程

三、课程安排

  • 数据库课程: 数据存储技术
  • 前端课程: 页面展示技术
  • web核心课程: 服务器端编程技术
  • 项目课程:使用web技术完成《黑马旅游网》项目

四、后期学习路径

  • SSM框架: 简化web开发的经典框架
  • SpringBoot: 简化Spring开发的框架
  • SpringCloud: 微服务开发解决方案
  • 各种中间件技术:
    • Redis
    • MongoDB
    • RabbitMQ
    • ElasticSearch
  • 容器技术: Docker
  • 业务解决方案

2. Java SE 内容补充

2.1 Junit单元测试

测试分类∶
  • 1．黑盒测试∶不需要写代码，给输入值，看程序是否能够输出期望的值
  • 2．白盒测试︰需要写代码的。关注程序具体的执行流程（Junit单元测试属于白盒测试）

JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第2张图片

Junit使用∶
在main方法里的测试

计算器类 

package cn.itcast.junit;
/**
 * 计算器类
 */
public class Calculator {
    /**
     * 加法
     * @param a
     * @param b
     * @return
     */
    public int add (int a , int b){
        //int i = 3/0;
       // return a - b;
        return a + b;
    }
    /**
     * 减法
     * @param a
     * @param b
     * @return
     */
    public int sub (int a , int b){
        return a - b;
    }
}

以上代码可能报错>>报错的处理
在main方法里的测试： 

package cn.itcast.junit;
public class CalculatorTest {
    public static void main(String[] args) {
        //创建对象
        Calculator c = new Calculator();
        //调用
       /* int result = c.add(1, 2);
        System.out.println(result);*/

        int result = c.sub(1, 1);
        System.out.println(result);

        String str = "abc";
    }
}
Junit单元测试(白盒测试)

Junit使用步骡∶

  • 1．定义一个测试类(测试用例)

    • 建议︰
      • 测试类名︰被测试的类名Test 如calculatorTest
      • 包名∶xxx.xxx.xx.test 如cn.itcast.test

  • 2．定义测试方法:可以独立运行

    • 建议:
      • 方法名: test测试的方法名 如testAdd()
      • 返回值: void
      • 参数列表:空参

  • 3．给方法加@Test注解

  • 4.导入junit依赖环境

  • 5.判定结果∶

    • 红色∶失败
    • 绿色: 成功
    • —般会使用断言操作来处理结果 Assert.assertEquals (期望的结果,运算的结果)

例程：

package cn.itcast.test;
import cn.itcast.junit.Calculator;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class CalculatorTest {
    /**
     * 初始化方法：
     *  用于资源申请，所有测试方法在执行之前都会先执行该方法
     */
    @Before
    public void init(){
        System.out.println("init...");
    }

    /**
     * 释放资源方法：
     *  在所有测试方法执行完后，都会自动执行该方法
     */
    @After
    public void close(){
        System.out.println("close...");
    }


    /**
     * 测试add方法
     */
    @Test
    public void testAdd(){
       // System.out.println("我被执行了");
        //1.创建计算器对象
        System.out.println("testAdd...");
        Calculator c  = new Calculator();
        //2.调用add方法
        int result = c.add(1, 2);
        //一般不用输出来看效果，而是使用断言来让结果和预期相比较
        //System.out.println(result);

        //3.断言  我断言这个结果是3
        Assert.assertEquals(3,result);

    }

    @Test
    public void testSub(){
        //1.创建计算器对象
        Calculator c  = new Calculator();
        int result = c.sub(1, 2);
        System.out.println("testSub....");
        Assert.assertEquals(-1,result);
    }
}
  • 补充∶
    • @Before:
      • 修饰的方法会在测试方法之前被自动执行
    • @After:
      • 修饰的方法会在测试方法执行之后自动被执行

2.2 反射

  • Java代码在计算机中经历的阶段:三个阶段
    • Source源代码阶段
    • Class类对象阶段
    • Runtime运行时阶段

JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第3张图片

  • 反射:框架设计的灵魂
    • 框架:半成品软件。可以在框架的基础上进行软件开发，简化编码
    • 反射:将类的各个组成部分封装为其他对象，这就是反射机制
    • 反射机制好处∶
      • 1．可以在程序运行过程中，操作这些对象
      • 2．可以解耦，提高程序的可扩展性
获取class对象的方式
  • 1.class.forName(“全类名”):将字节码文件加载进内存，返回class对象
    • 多用于配置文件，将类名定义在配置文件中。读取文件，加载类
  • 2．类名.class :通过类名的属性class获取
    • 多用于参数的传递
  • 3．对象.getClass() : getClass()方法是在Object类中定义
    • 多用于对象的获取字节码的方式

例程： 获取class对象 

package cn.itcast.reflect;
import cn.itcast.domain.Person;
import cn.itcast.domain.Student;
public class ReflectDemo1 {
    /**
        获取Class对象的方式：
            1. Class.forName("全类名")：将字节码文件加载进内存，返回Class对象
            2. 类名.class：通过类名的属性class获取
            3. 对象.getClass()：getClass()方法在Object类中定义着。
     */
    public static void main(String[] args) throws Exception {

        //1.Class.forName("全类名")
        //全类名全类名：包名加类名
        Class cls1 = Class.forName("cn.itcast.domain.Person");
        System.out.println(cls1);
        //2.类名.class
        Class cls2 = Person.class;
        System.out.println(cls2);
        //3.对象.getClass()
        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);

        //== 比较三个对象
        System.out.println(cls1 == cls2);//true
        System.out.println(cls1 == cls3);//true


        Class c = Student.class;
        System.out.println(c == cls1);
        /* 输出：
            class cn.itcast.domain.Person
            class cn.itcast.domain.Person
            class cn.itcast.domain.Person
            true
            true
            false
         */
    }
}

结论∶
同一个字节码文件(*.class)在一次程序运行过程中，只会被加载一次，不论通过哪一种方式获取的class对象都是同一个

Person类：

package cn.itcast.domain;
public class Person {
    private String name;
    private int age;
    public String a;
    protected String b;
    String c;
    private String d;
    public Person() {
    }
    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                ", b='" + b + '\'' +
                ", c='" + c + '\'' +
                ", d='" + d + '\'' +
                '}';
    }
    public void eat(){
        System.out.println("eat...");
    }
    public void eat(String food){
        System.out.println("eat..."+food);
    }
}

Student类

package cn.itcast.domain;
public class Student {
    public void sleep(){
        System.out.println("sleep...");
    }
}
class对象功能∶
  • 获取功能︰
    • 1．获取成员变量们
      • Field[] getFields() 获取所有public修饰的成员变量
      • Field getField(string name) 获取指定名称的 public修饰的成员变量
      • Field[] getDeclaredFields() 获取所有的成员变量，不考虑修饰符
      • Field getDeclaredField(string name)
    • 2．获取构造方法们
      • constructor[] getconstructors()
      • constructor< T > getconstructor(类… parameterTypes)
      • constructor< T> getDeclaredconstructor(类… parameterTypes)
      • constructor[]getDeclaredconstructors()
    • 3．获取成员方法们︰
      • Method[] getMethods()
      • Method getMethod(string name，类… parameterTypes)
      • Method[] getDeclaredMethods()
      • Method getDeclaredMethod(string name，类… parameterTypes)
    • 4．获取类名
      • string getName()
获取成员变量
  • Field :成员变量操作 :
    • 1.设置值
      • void set(object obj, object value)
    • 2．获取值
      • get(object obj)
    • 3．忽略访问权限修饰符的安全检查
      • setAccessible(true):暴力反射
      • constructor:构造方法
    • 创建对象∶
      • T newInstance(object. . . initargs)
      • 如果使用空参数构造方法创建对象，操作可以简化: Class对象的newInstance方法

例程： 获取成员变量 

package cn.itcast.reflect;
import cn.itcast.domain.Person;
import java.lang.reflect.Field;
public class ReflectDemo2 {
    /**
     Class对象功能：
         * 获取功能：
         1. 获取成员变量们
             * Field[] getFields()
             * Field getField(String name)

             * Field[] getDeclaredFields()
             * Field getDeclaredField(String name)
     */
    public static void main(String[] args) throws Exception {

        //0.获取Person的Class对象
        Class personClass = Person.class;
        /*
             1. 获取成员变量们
                 * Field[] getFields()
                 * Field getField(String name)

                 * Field[] getDeclaredFields()
                 * Field getDeclaredField(String name)

         */
        //1.Field[] getFields()获取所有public修饰的成员变量
        Field[] fields = personClass.getFields();
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("===================");
        //2.Field getField(String name)
        Field a = personClass.getField("a");
        //获取成员变量a 的值
        Person p = new Person();
        Object value = a.get(p);
        System.out.println(value);
        //设置a的值
        a.set(p,"张三");
        System.out.println(p);

        System.out.println("===================");

        //Field[] getDeclaredFields()：获取所有的成员变量，不考虑修饰符
        Field[] declaredFields = personClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println(declaredField);
        }
        System.out.println("===================");
        //Field getDeclaredField(String name)
        Field d = personClass.getDeclaredField("d");
        //忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);
        /*  输出：
            public java.lang.String cn.itcast.domain.Person.a
            ===================
            null
            Person{name='null', age=0, a='张三', b='null', c='null', d='null'}
            ===================
            private java.lang.String cn.itcast.domain.Person.name
            private int cn.itcast.domain.Person.age
            public java.lang.String cn.itcast.domain.Person.a
            protected java.lang.String cn.itcast.domain.Person.b
            java.lang.String cn.itcast.domain.Person.c
            private java.lang.String cn.itcast.domain.Person.d
            ===================
            null
         */
    }
}
获取构造方法
  • constructor:构造方法
    • 创建对象︰
      • T newInstance(object. … initargs)
      • 如果使用空参数构造方法创建对象，操作可以简化:class对象的newInstance方法

例程二： 获取构造方法 

package cn.itcast.reflect;
import cn.itcast.domain.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
public class ReflectDemo3 {
    /**
     Class对象功能：
         * 获取功能：
         2. 获取构造方法们
             * Constructor[] getConstructors()
             * Constructor getConstructor(类... parameterTypes)

             * Constructor getDeclaredConstructor(类... parameterTypes)
             * Constructor[] getDeclaredConstructors()
     */
    public static void main(String[] args) throws Exception {

        //0.获取Person的Class对象
        Class personClass = Person.class;
        //Constructor getConstructor(类... parameterTypes)
        Constructor constructor = personClass.getConstructor(String.class, int.class);
        System.out.println(constructor);
        //创建对象
        Object person = constructor.newInstance("张三", 23);
        System.out.println(person);

        System.out.println("====================");

        Constructor constructor1 = personClass.getConstructor();
        System.out.println(constructor1);
        //创建对象
        Object person1 = constructor1.newInstance();
        System.out.println(person1);

        Object o = personClass.newInstance();
        System.out.println(o);
        //constructor1.setAccessible(true);
        /*   输出：
            public cn.itcast.domain.Person(java.lang.String,int)
            Person{name='张三', age=23, a='null', b='null', c='null', d='null'}
            ====================
            public cn.itcast.domain.Person()
            Person{name='null', age=0, a='null', b='null', c='null', d='null'}
            Person{name='null', age=0, a='null', b='null', c='null', d='null'}
         */
    }
}
获取成员方法 & 获取类名
  • Method :方法对象
    • 执行方法︰object invoke(object obj， object.
    • . . args) 获取方法名称:
      • string getName :获取方法名
package cn.itcast.reflect;
import cn.itcast.domain.Person;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class ReflectDemo4{
    /**
     Class对象功能：
         * 获取功能：
         3. 获取成员方法们：
             * Method[] getMethods()
             * Method getMethod(String name, 类... parameterTypes)
             * Method[] getDeclaredMethods()
             * Method getDeclaredMethod(String name, 类... parameterTypes)

        4. 获取类名   string getName()
     */
    public static void main(String[] args) throws Exception {
        //0.获取Person的Class对象
        Class personClass = Person.class;
        //获取指定名称的方法
        Method eat_method = personClass.getMethod("eat");
        Person p = new Person();
        //执行方法
        eat_method.invoke(p);


        Method eat_method2 = personClass.getMethod("eat", String.class);
        //执行方法
        eat_method2.invoke(p,"饭");
        /*输出：
             eat...
             eat...?
         */

        System.out.println("====================");

        //获取所有public修饰的方法
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
            String name = method.getName();
            System.out.println(name);
            //method.setAccessible(true);
        }
        /*输出：
            public java.lang.String cn.itcast.domain.Person.getName()
    getName
            public java.lang.String cn.itcast.domain.Person.toString()
            toString
            public void cn.itcast.domain.Person.setName(java.lang.String)
            setName
            public void cn.itcast.domain.Person.eat()
            eat
            public void cn.itcast.domain.Person.eat(java.lang.String)
            eat
            public void cn.itcast.domain.Person.setAge(int)
            setAge
            public int cn.itcast.domain.Person.getAge()
            getAge
            public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
            wait
            public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
            wait
            public final void java.lang.Object.wait() throws java.lang.InterruptedException
            wait
            public boolean java.lang.Object.equals(java.lang.Object)
            equals
            public native int java.lang.Object.hashCode()
            hashCode
            public final native java.lang.Class java.lang.Object.getClass()
            getClass
            public final native void java.lang.Object.notify()
            notify
            public final native void java.lang.Object.notifyAll()
            notifyAll
         */

        System.out.println("====================");
        //获取类名
        String className = personClass.getName();
        System.out.println(className);//  输出：cn.itcast.domain.Person
    }
}
反射案例
  • 案例需求:
    • 写一个"框架"，在不改变该类的任何代码的前提下，可以帮我们创建任意类的对象，并且执行其中任意方法
  • 实现:
    • 1．配置文件
    • 2．反射
  • 步骤:
    • 1．将需要创建的对象的全类名和需要执行的方法定义在配置文件中
    • 2．在程序中加载读取配置文件
    • 3．使用反射技术来加载类文件进内存
    • 4．创建对象
    • 5．执行方法

案例代码：

package cn.itcast.reflect;
import cn.itcast.domain.Person;
import cn.itcast.domain.Student;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
 * 框架类
 */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //可以创建任意类的对象，可以执行任意方法
        /*
            前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
         */
      /*  Person p = new Person();
        p.eat();*/
/*
        Student stu = new Student();
        stu.sleep();*/

        //1.加载配置文件
        //1.1创建Properties对象
        Properties pro = new Properties();
        //1.2加载配置文件，转换为一个集合
        //1.2.1获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();
        InputStream is = classLoader.getResourceAsStream("pro.properties");
        pro.load(is);
        /*    配置文件内容：
              className=cn.itcast.domain.Student
              methodName=sleep
         */

        //2.获取配置文件中定义的数据
        String className = pro.getProperty("className");
        String methodName = pro.getProperty("methodName");

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
        //输出：sleep...
    }
}

2.3 注解

注解概述
  • 注解概念︰说明程序的。给计算机看的
  • 回顾注释:用文字描述程序的。给程序员看的
  • 定义: 注解(Annotation)，也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引又的一个特性，与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释；
  • 注解概念描述∶
    • JDK1.5之后的新特性
    • 说明程序的
    • 使用注解∶@注解名称
  • 作用分类︰
    • 编写文档:通过代码里标识的注解生成文档【生成文档doc文档】
    • 代码分析∶通过代码里标识的注解对代码进行分析【使用反射】
    • 编译检查:通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
注释javadoc演示

1. 编写演示代码：

package cn.itcast.annotation;
/**
 * 注释javadoc演示
 * @author itcat
 * @version 1.0
 * @since 1.5
 */
public class AnnoDemo1 {
    /**
     * 计算两数的和
     * @param a 整数
     * @param b 整数
     * @return 两数的和
     */

       /**** 
       * @Description: add 
       *   * @param a
        * @param b 
       * @return: int 
       * @Author: Mr.Cao
       * @Date: 2018/6/18 
       */ 
    public int add(int a, int b ){
        return a + b;
    }
    /**
    * @Description: summ
    * @Param: [a, b]
    * @return: int
    * @Author: Mr.Cao
    * @Date: 2018/6/18    tab+a+/
    */

    public  int summ(int a,int b){
        return a+b;
    }
}

通过一下步骤查看文档注释

JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第4张图片 2. 将类拷贝到指定文件夹中
JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第5张图片3. 用文本文档打开Java文件，并把代码头部的包去掉
JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第6张图片 4. 在Java文件所在的目录下点击Alt+d
JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第7张图片 5. 在上方输入cmd打开命令行窗口
JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第8张图片 6. 在命令行中输入javadoc AnnoDemo1.java，在当前目录下就会生成文档注释
JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第9张图片 7. 查看index.html文档注释
JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第10张图片 8. 文档注释如上（官方文档也是通过文档注释得到的）：
JDK中预定义的一些注解
  • @override :
    • 检测被该注解标注的方法是否是继承自父类(接口)的
  • @Deprecated :
    • 该注解标注的内容，表示已过时
  • @suppresswarnings :
    • 压制警告
      • —般传递参数all: @suppresswarnings( “all”)
package cn.itcast.annotation;
import java.util.Date;
/**
 * JDK中预定义的一些注解
 * 		* @Override	：检测被该注解标注的方法是否是继承自父类(接口)的
 * 		* @Deprecated：该注解标注的内容，表示已过时
 * 		* @SuppressWarnings：压制警告
 */

@SuppressWarnings({"all", "all"})
public class AnnoDemo2 {
    @Override
    public String toString() {
        return super.toString();
    }
    @Deprecated//过期注解
    public void show1(){
        //有缺陷
    }
    public void show2(){
        //替代show1方法
    }
    public void demo(){
        show1();
        Date date = new Date();
    }
}
自定义注解
语法格式
  • 自定义注解格式:
    元注解
    public @interface注解名称{}
  • 本质:
    • 注解本质上就是一个接口，该接口默认继承Annotation接口
    • public interface MyAnno extends java.lang.annotation.Annotation {}
  • 自定义注解 MyAnno：
    • 步骤： new 一个MyAnno类,将class改为@interface即可：
package cn.itcast.annotation;
//import com.sun.corba.se.spi.orbutil.threadpool.Work;
public @interface MyAnno {

     int value();
    Person per();
    MyAnno2 anno2();
    String[] strs();
     /*String name() default "张三";*/
     /*String show2();

     Person per();
     MyAnno2 anno2();

     String[] strs();*/
}

在文件路径下对其进行反编译：
JavaWeb笔记： 第01章_JavaSE回顾——Junit单元测试&反射&注解_第11张图片

  • 由反编译结果可知：
    • 注解本质上就是一个接口，该接口默认继承Annotation接口
注解中的属性
  • 属性:接口中的抽象方法
  • 要求∶
    • 1.属性的返回值类型只能是下列取值
      • 基本数据类型
      • string
      • 枚举
      • 注解
      • 以上类型的数组
    • 2．定义了属性，在使用时需要给属性赋值
      • 1.如果定义属性时，使用default关键字给属性默认初始化值，则使用注解时，可以不进行属性的赋值。
      • 2.如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可
      • 3．数组赋值时，值使用{}包裹。如果数组中只有一个值，则省略

枚举类 

package cn.itcast.annotation;
public enum Person {
    P1,P2,P3;
}

注解 

package cn.itcast.annotation;
//import com.sun.corba.se.spi.orbutil.threadpool.Work;
public @interface MyAnno {
     int value();
    Person per();
    MyAnno2 anno2();
    String[] strs();
     /*String name() default "张三";*/
     /*String show2();

     Person per();
     MyAnno2 anno2();

     String[] strs();*/
}

注解的赋值 

package cn.itcast.annotation;
@MyAnno(value=12,per = Person.P3,anno2 = @MyAnno2,strs={"bbb","aaa"})
@MyAnno3
public class Worker {
    @MyAnno3
    public String name = "aaa";
    @MyAnno3
    public void show(){
    }
}
元注解
  • 元注解:用于描述注解的注解
    • @Target :描述注解能够作用的位置
      • ElementType取值:
        • TYPE:可以作用于类上
        • METHOD :可以作用于方法上
        • FIELD:可以作用于成员变量上
    • @Retention :描述注解被保留的阶段
      • @Retention(RetentionPolicy.RUNTIME)∶当前被描述的注解，会保留到class字节码文件中，并被JVM读取到
    • @Documented:描进注解是否被抽取到api文档中
    • @Inherited :描述注解是否被子类继承
package cn.itcast.annotation;
import java.lang.annotation.*;
/**
 元注解：用于描述注解的注解
     * @Target：描述注解能够作用的位置
     * @Retention：描述注解被保留的阶段
     * @Documented：描述注解是否被抽取到api文档中
     * @Inherited：描述注解是否被子类继承
 */
//表明MyAnno3可以作用于类上，方法上，成员变量上
@Target({ElementType.TYPE,ElementType.METHOD,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface MyAnno3 {
}
使用(解析)注解

在程序使用(解析)注解: 获取注解中定义的属性值

  • 1．获取注解定义的位置的对象(class,Method,Field)
  • 2．获取指定的注解: getAnnotation(Class)
//获取指定的注解: getAnnotation(Class)
//其实就是在内存中生成了一个该注解接口的子类实现对象
public class ProImpl implements Pro{
public string className(){
return "cn.itcast.annotation.Demo1";
}
public string methodName(){
return "show";
}
}
  • 3．调用注解中的抽象方法获取配置的属性值
  • 4.注解通常是用来代替配置文件的

定义Pro注解 

package cn.itcast.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
 * 描述需要执行的类名，和方法名
 */
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface Pro {
    String className();//代表了一套规范
    String methodName();
}

定义Demo1类，实现成员方法show() 

package cn.itcast.annotation;
public class Demo1 {
    public void show(){
      System.out.println("demo1...show...");
    }
}

定义Demo2类，实现成员方法show() 

package cn.itcast.annotation;
public class Demo2 {
    public void show(){
        System.out.println("demo2...show...");
    }
}

使用 自定义的注解Pro 代替 配置文件 实现前面写过的框架类 

package cn.itcast.annotation;
import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.Properties;
/**
 * 框架类
 */
@Pro(className = "cn.itcast.annotation.Demo1",methodName = "show")
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        /*
            前提：不能改变该类的任何代码。可以创建任意类的对象，可以执行任意方法
         */
        //1.解析注解
        //1.1获取该类的字节码文件对象
        Class<ReflectTest> reflectTestClass = ReflectTest.class;
        //2.获取上边的注解对象
        //其实就是在内存中生成了一个该注解接口的子类实现对象
        /*相当于如下代码

            public class ProImpl implements Pro{
                public String className(){
                    return "cn.itcast.annotation.Demo1";
                }
                public String methodName(){
                    return "show";
                }

            }
 */
        Pro an = reflectTestClass.getAnnotation(Pro.class);
        //3.调用注解对象中定义的抽象方法，获取返回值
        String className = an.className();
        String methodName = an.methodName();
        System.out.println(className);
        System.out.println(methodName);

        //3.加载该类进内存
        Class cls = Class.forName(className);
        //4.创建对象
        Object obj = cls.newInstance();
        //5.获取方法对象
        Method method = cls.getMethod(methodName);
        //6.执行方法
        method.invoke(obj);
        /*输出：
            cn.itcast.annotation.Demo1
            show
            demo1...show...
         */
    }
}
注解使用案例

定义Check注解 

package cn.itcast.annotation.demo;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Check {
}

定义Calculator类 

package cn.itcast.annotation.demo;
/**
 * 小明定义的计算器类
 */
public class Calculator {
    //加法
    @Check
    public void add(){
        String str = null;
        str.toString();
        System.out.println("1 + 0 =" + (1 + 0));
    }
    //减法
    @Check
    public void sub(){
        System.out.println("1 - 0 =" + (1 - 0));
    }
    //乘法
    @Check
    public void mul(){
        System.out.println("1 * 0 =" + (1 * 0));
    }
    //除法
    @Check
    public void div(){
        System.out.println("1 / 0 =" + (1 / 0));
    }
    
    public void show(){
        System.out.println("永无bug...");
    }

}

测试 

package cn.itcast.annotation.demo;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
/**
 * 简单的测试框架
 * 当主方法执行后，会自动自行被检测的所有方法(加了Check注解的方法)，判断方法是否有异常，记录到文件中
 */
public class TestCheck {

    public static void main(String[] args) throws IOException {
        //1.创建计算器对象
        Calculator c = new Calculator();
        //2.获取字节码文件对象
        Class cls = c.getClass();
        //3.获取所有方法
        Method[] methods = cls.getMethods();

        int number = 0;//出现异常的次数
        BufferedWriter bw = new BufferedWriter(new FileWriter("bug.txt"));


        for (Method method : methods) {
            //4.判断方法上是否有Check注解
            if(method.isAnnotationPresent(Check.class)){
                //5.有，执行
                try {
                    method.invoke(c);
                } catch (Exception e) {
                    //6.捕获异常

                    //记录到文件中
                    number ++;

                    bw.write(method.getName()+ " 方法出异常了");
                    bw.newLine();
                    bw.write("异常的名称:" + e.getCause().getClass().getSimpleName());
                    bw.newLine();
                    bw.write("异常的原因:"+e.getCause().getMessage());
                    bw.newLine();
                    bw.write("--------------------------");
                    bw.newLine();

                }
            }
        }
        bw.write("本次测试一共出现 "+number+" 次异常");
        bw.flush();
        bw.close();
        /* 运行输出：
                   1 - 0 =1
                   1 * 0 =0
         */
    }
}

测试运行结果： 1、2
1.控制台输出

1 - 0 =1
1 * 0 =0

2.out目录下生成文件bug.txt文件，文件内容如下：

add 方法出异常了
异常的名称:NullPointerException
异常的原因:null
--------------------------
div 方法出异常了
异常的名称:ArithmeticException
异常的原因:/ by zero
--------------------------
本次测试一共出现 2 次异常
小结:
  • 1．以后大多数时候，我们会使用注解，而不是自定义注解
  • 2．注解给谁用?
    • 1．编译器
    • 2．给解析程序用
    • 3．注解不是程序的一部分，可以理解为注解就是一个标签

说明：本内容整理自黑马程序员B站Java web视频>>黑马程序员B站Java web视频

你可能感兴趣的:(Java,web笔记,java,java,web)

  • 解决 Lombok 与 Java 模块系统的兼容性问题：从错误到解决方案 码农阿豪@新空间代码工作室 包罗万象java开发语言
    个人名片作者简介：java领域优质创作者个人主页：码农阿豪工作室：新空间代码工作室（提供各种软件服务)个人邮箱：[[email protected]]个人微信：15279484656个人导航网站：www.forff.top座右铭：总有人要赢。为什么不能是我呢？专栏导航：码农阿豪系列专栏导航面试专栏：收集了java相关高频面试题，面试实战总结️Spring5系列专栏：整理了Spring5重要知识点与
  • github最强Chatbox AI 模型桌面，支持 ChatGPT、Claude等主流模型，适用于 Win、Linux等，总结文档图片并互动，智能编程，AI实时联网搜索与查询，图片生成，科研写作等 struggle2025 人工智能深度学习语音识别计算机视觉语言模型图像处理数据分析
    一、软件介绍（文末提供下载）Chatbox是一个AI模型桌面客户端，支持ChatGPT、Claude、GoogleGemini、Ollama等主流模型，适用于Windows、Mac、Linux、Web、Android和iOS全平台。github地址：GitHub-Bin-Huang/chatbox:User-friendlyDesktopClientAppforAIModels/LLMs(GPT,
  • 【uniapp】uniapp使用java线程池 新青年. uni-appjavascript
    标题由于js是性能孱弱的单线程语言，只要在渲染中执行了一些其他操作，会中断渲染，导致页面卡死，卡顿，吐司不消失等问题。在安卓端可以调用java线程池，把耗时操作写入线程池里面，优化性能。实现使用native.js,直接贴出代码classJavaExecutorPool{constructor(){//#ifdefAPP-PLUSconstScheduledThreadPoolExecutor=pl
  • Python中使用SQLite 昂热校长
    开发十年，就只剩下这套Java开发体系了>>>SQLite：SQLite是一种数据库，Python中集成了SQLite3，所以在Python中使用SQLite，可以直接导入SQLite包，不需要做额外的配置。更多的SQLite简介和相关知识可以查看专门的教程：http://www.runoob.com/sqlite/sqlite-tutorial.htmlPython中使用SQLite:可以直接像
  • 深入探讨：服务器如何响应前端请求及后端如何查看前端提交的数据 我的青春不太冷 服务器前端运维
    深入探讨：服务器如何响应前端请求及后端如何查看前端提交的数据一、服务器如何响应前端请求前端与后端的交互主要通过HTTP协议实现。以下是详细步骤：1.前端发起HTTP请求GET请求：用于从服务器获取数据。POST请求：用于向服务器提交数据。例如，使用JavaScript的fetchAPI发送POST请求：fetch('https://example.com/api/data',{method:'PO
  • JavaScript逆向高阶指南：突破基础，掌握核心逆向技术 不做超级小白 web逆向知识碎片web前端javascript开发语言ecmascript
    JavaScript逆向高阶指南：突破基础，掌握核心逆向技术JavaScript逆向工程是Web开发者和安全分析师的核心竞争力。无论是解析混淆代码、分析压缩脚本，还是逆向Web应用架构，掌握高阶逆向技术都将助您深入理解复杂JavaScript逻辑。本文将通过实战案例，带您探索JavaScript逆向的深层技术原理。1.JavaScript反混淆实战现代Web应用常采用多重混淆技术保护代码，以下为高
  • 小白一命速通JS中的window&global对象 不做超级小白 web前端javascript开发语言ecmascript
    笔者注意到JS中的window对象与global对象经常被混淆，尽管它们在相当一部分使用情况下可以等同，但是本质上仍然存在很多不同，下面是对于两者的详细拆解1.window对象定义：window对象表示浏览器环境中的全局上下文。作用域：它是浏览器中运行的任何JavaScript代码的顶级对象。关键特性：包含所有通过var声明的全局变量和函数（在非模块脚本中）。表示浏览器的窗口或框架，代码运行在其中
  • Mybatis初步了解 孙尚香蕉 mybatismybatisoracle数据库
    mysql缓存：根据sql语句进入缓存，如果sql语句多加一个空格就进入不到同一个缓存，另外数据库数据发生了更新，缓存中的数据不会同步。延迟加载：先查询基本信息，再查询其他信息，而不是一次就查询出来。mybatis的框架概述数据库厂商都会有自己的驱动包，上面一层对jdbc进行接口规范（对jdbc进行封装），再上一层mybatis框架MyBatis是一个优秀的基于Java的持久层框架，内部对JDBC
  • 软件体系结构——基于事件的隐式调用风格 阴天快乐、、 软件体系结构Java
    基于事件的隐式调用风格的基本组件是对象或过程，并分类为以下更小的组件：过程或函数。充当事件源或事件处理器的角色。连接件是事件-过程绑定。组件可以声明或广播一个或多个事件，或者向系统注册，来表明他希望响应一个或多个事件。当某些事件被触发时，向其注册的过程被隐式调用，调用的次序是不确定的。程序示例如下：【功能】：点击窗口程序使显示的文字发生改变。importjava.awt.*;importjava.
  • 架构整合要点。 jc_dreaming2 OPENSpringStrutsJavaHibernateXML
    整合spring2+struts1.2+hibernate3.2程序要使用spring2,需要spring插件jar包和spring的类库外。1.web.xml配置spring的监听。org.springframework.web.context.ContextLoaderListener通过contextConfigLocation上下文参数指定spring配置文件javax.servlet.j
  • Java基础语法（一） 邮专小谦 pythonjava算法
    一、基础语法数据类型基本数据类型：整数类型：包括byte（1字节，范围是-128到127）、short（2字节，范围是-32768到32767）、int（4字节，范围是-2147483648到2147483647）和long（8字节）。例如，定义一个int类型的变量intnum=10;。浮点类型：float（4字节）和double（8字节）。float类型的数值后面需要加f或F，如floatf=3
  • Java 的字符串操作（一） 邮专小谦 python开发语言
    字符串的定义在Java中，字符串是一个对象，它是java.lang.String类的实例。可以通过以下两种常见方式定义字符串：直接赋值：Stringstr="HelloWorld";，这种方式简单直接，Java会自动在字符串常量池中查找是否已经存在相同内容的字符串，如果有就直接引用，没有则创建新的字符串对象并放入常量池。使用new关键字：Stringstr=newString("HelloWorl
  • OpenAI 函数调用 功能入门 AI火箭 chatgptopenai
    Javascript版Langchain入门作者：AI小火箭的HB我是AI小火箭的HB，我探索和写作人工智能和语言交叉点的所有事物，范围从LLM，聊天机器人，语音机器人，开发框架，以数据为中心的潜在空间等。介绍LangChain是一个开源Python库，用于构建由大型语言模型（LLM）支持的应用程序。它提供了一个框架，将LLM与其他数据源（如互联网或个人文件）连接起来，允许开发人员将多个命令链接在
  • 基于Python增加抖音视频播放量的代码 sh_moranliunian 蜘蛛侠网络爬虫后端python爬虫
    一、思路通过发送HTTP请求来实现这一功能。代码主要功能的简要介绍：1.`get_ttwid`：这个函数用于获取`ttwid`，它是通过向字节跳动的接口发送POST请求，并从响应的cookie中提取`ttwid`值。2.`get_web_id`：这个函数用于获取`web_id`，它是通过向某个API发送POST请求，并从响应中提取`web_id`。3.`get_ms_token`：这个函数生成一个
  • 分层架构设计概念 祈遇& java
    技术架构分层设计  系统分层设计是一种设计思想（分而治之），是让每层对象都有一个独立职责，再让多层对象协同（耦合）完成一个完整的功能。这样做可以更好提高系统可扩展性,但同时也会增加系统整体运维的难度springBoot技术简介和特性  SpringBoot是Java软件开发框架（很多人现在把它理解为一个脚手架），其设计目的是用来简化Spring项目的初始搭建以及开发过程。该框架使用了特定的注解方式
  • Python 库的记录 weixin_40895135 python
    GitHub-jobbole/awesome-python-cn:Python资源大全中文版，内容包括：Web框架、网络爬虫、网络内容提取、模板引擎、数据库、数据可视化、图片处理、文本处理、自然语言处理、机器学习、日志、代码分析等环境管理管理Python版本和环境的工具p–非常简单的交互式python版本管理工具。pyenv–简单的Python版本管理工具。Vex–可以在虚拟环境中执行命令。vir
  • 第23节课：前端调试技巧—掌握浏览器开发者工具与性能优化 学问小小谢 HTML学习前端性能优化交互html5安全学习
    目录浏览器开发者工具常见的浏览器开发者工具浏览器开发者工具的基本使用打开开发者工具开发者工具的面板使用开发者工具进行调试Elements面板检查和编辑HTML检查和编辑CSSConsole面板输出日志和调试信息执行JavaScript代码Network面板监控网络请求分析请求和响应Performance面板记录和分析性能优化性能Application面板检查和管理资源调试存储性能优化与调试性能优化
  • 第20节课： jQuery基础—简化JavaScript编程的强大工具 学问小小谢 HTML学习javascriptjquery前端html学习交互搜索引擎
    目录jQuery简介为什么使用jQuery？jQuery选择器基本选择器属性选择器伪类选择器事件处理事件绑定常见事件类型事件触发动画效果基本动画自定义动画实践：使用jQuery增强网页交互示例：创建一个带有动画效果的按钮示例：创建一个交互式的导航菜单结语在Web开发中，JavaScript是实现网页交互和动态效果的核心语言。然而，原生JavaScript的语法有时显得繁琐，为了提高开发效率，jQu
  • leetcode——分割两个字符串得到一个回文字符串（java） gentle_ice leetcodejava算法
    给你两个字符串a和b，它们长度相同。请你选择一个下标，将两个字符串都在相同的下标分割开。由a可以得到两个字符串：aprefix和asuffix，满足a=aprefix+asuffix，同理，由b可以得到两个字符串bprefix和bsuffix，满足b=bprefix+bsuffix。请你判断aprefix+bsuffix或者bprefix+asuffix能否构成回文串。当你将一个字符串s分割成sp
  • 如何写一份合格的大数据简历（附简历模板）教程 itLeeyw573 老板必点的高分简历sqliteoraclemysqlsqlzookeeperkafkabigdata
    一、简历的重要性简历是求职者给招聘者的第一印象，一份合格的简历能够快速让招聘者了解你的基本信息、工作经历、技能特长等，从而决定是否给予你面试机会。它是开启理想工作大门的钥匙，所以一定要重视起来。【编辑/下载】：大数据开发简历范文二、简历结构基本信息：包含姓名、性别、联系方式（电话、邮箱）、求职意向。姓名要突出显示，联系方式务必准确无误，求职意向明确且具体，比如“Java开发工程师”，让招聘者一眼就
  • 构建新纪元：Gradle中Kotlin插件的配置全指南 2402_85758936 kotlin开发语言android
    构建新纪元：Gradle中Kotlin插件的配置全指南引言Kotlin，这门现代、简洁的语言，正在逐渐成为Java平台的有力补充。随着Kotlin在Android开发中的广泛采用，以及对服务器端和Web开发的支持，Kotlin插件在Gradle中的配置变得尤为重要。本文将深入探讨如何在Gradle中配置Kotlin插件，以充分利用Kotlin语言的强大功能。Kotlin与Gradle插件Kotli
  • leetcode——合并K个有序链表（java） gentle_ice leetcode链表java
    给你一个链表数组，每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中，返回合并后的链表。示例1：输入：lists=[[1,4,5],[1,3,4],[2,6]]输出：[1,1,2,3,4,4,5,6]解释：链表数组如下：[1->4->5,1->3->4,2->6]将它们合并到一个有序链表中得到。1->1->2->3->4->4->5->6示例2：输入：lists=[]输出：[]示例3：输
  • 代替Winform、Win32控件的一些界面框架Electron,QT等 专注VB编程开发20年 前端c++ui界面框架
    以下是一些可以代替Winform、Win32控件，在VC++、VBA等EXE程序上用来做控件元素、表格数据绑定、窗口显示的WEBUI框架和工具：1.Electron特点：Electron是一个使用JavaScript、HTML和CSS构建跨平台桌面应用程序的框架。它允许开发者使用Web技术来创建桌面应用，具有良好的跨平台兼容性。适用场景：适用于需要快速开发跨平台桌面应用的场景，尤其是对UI灵活性和
  • 1.“use strict“ 严格模式 - JS 个人意志想 #LittlePointsinJS笔记开发语言js学习
    JS严格模式JS严格模式是指令在JavaScript1.8.5（ECMAScript5、ES5）开始引入的；是一种旨在消除歧义、语法规范、维护安全的模式；通过语句"usestrict"进行声明。声明与作用域在文件头部声明，整个文件代码都要遵循严格模式；在函数内部开头声明，函数体遵循严格模式；函数的严格模式是最佳选择，没必要整个文件都严格，或者可以一个文件就写一个函数。限制不允许使用未声明的变量（对
  • JavaScript笔记（5）严格模式 way_hj JavaScript学习笔记javascript严格模式usestrict
    1.启用严格模式的指令："usestrict"或'usestrict'，即单引号或双引号均可，也许use将来会成为关键字。2."usestrict";以分号结尾，在不支持严格模式的浏览器中（如IE9及以下）被当作一般语句。3.必须作为全局或函数的首条语句才起到严格模式指令的作用，否则即是一条普通语句。usestrict;//严格模式指令必须在首行，如果之前有语句，它将被当作一个普通字符串，而不是启
  • 22、JavaScript学习笔记——ES5严格模式 lvh98 javascript学习前端
    ES5严格模式当前使用的ES语法是基于ES3.0的方法加上ES5.0的新增方法。默认情况下，ES3.0和ES5.0冲突的部分，会沿用ES3.0的方法；而在ES5.0严格模式下，冲突部分会使用ES5.0的方法。1.“usestrict”不再兼容ES3.0的一些不规则语法。使用全新的ES5.0规范。1.1ES5.0严格模式的启动要选择使用严格模式，需要使用严格模式编译指示（pragma），即一个不赋值
  • FastAPI：一个贼快的Python Web框架 程序媛千千 fastapipython
    Python，作为一个强大而灵活的编程语言，提供了多种框架来简化Web开发过程。其中，FastAPI是一个很新但极其强大的库，它允许开发者以极简的代码高效地构建API。什么是FastAPI？FastAPI是一个现代、快速（高性能）的Web框架，用于构建API与Web应用程序。它基于标准Python类型提示这一特性，提供了多项功能，如数据验证、序列化、文档生成等。为什么选择FastAPI？速度：Fa
  • 一个真正可用的docker-compse部署 单机版kafka 版本2.x garen_dimon 软件研究dockerkafka容器
    注意：kafka3.x版本，Kafka3.x需要Java11或更高版本。确保系统已安装合适的Java版本。Kafka3.x推荐使用ZooKeeper3.5.x或更高版本。确保ZooKeeper集群与Kafka版本兼容。如果你计划使用KRaft模式替换传统的ZooKeeper模式，请确保你已经了解新模式的要求和配置。在网上搜索单机docker-compose部署kafka，出现最多的内容如下：ver
  • 用SpringBoot+mysql+html实现ATM 系统总结与扩展 SAFE20242034 #一SpringBootspringbootmysqlhtml
    这里写目录标题ATM系统总结与扩展项目概述主要功能模块1.用户注册2.用户登录3.账户查询4.存款与取款5.转账6.修改密码7.销户系统改进建议功能扩展技术优化完整代码实现数据库表设计后端代码（SpringBoot示例）1.Account实体类2.AccountRepository接口3.AccountController类前端代码（HTML+JavaScript示例）实际开发与部署步骤**1.开
  • Java 核心与应用：Java 继承与多态 码力全開 《Java核心与应用》javapython开发语言
    目录Java核心与应用：Java继承与多态引言1.Java继承基础1.1什么是继承？1.1.1继承的语法1.1.2继承的类型1.2方法重写（Override）1.2.1方法重写的规则1.2.2方法重写vs方法重载1.3继承体系中的构造方法调用链1.3.1构造方法调用链的执行顺序1.4动态绑定原理与虚方法表1.4.1动态绑定的实现原理1.4.2虚方法表的结构1.5继承的缺陷与组合优于继承原则1.5.
  • 二分查找排序算法 周凡杨 java二分查找排序算法折半
    一：概念 二分查找又称 折半查找（ 折半搜索/ 二分搜索），优点是比较次数少，查找速度快，平均性能好；其缺点是要求待查表为有序表，且插入删除困难。因此，折半查找方法适用于不经常变动而 查找频繁的有序列表。首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表 分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步
  • java中的BigDecimal bijian1013 javaBigDecimal
            在项目开发过程中出现精度丢失问题，查资料用BigDecimal解决，并发现如下这篇BigDecimal的解决问题的思路和方法很值得学习，特转载。         原文地址：http://blog.csdn.net/ugg/article/de
  • Shell echo命令详解 daizj echoshell
    Shell echo命令 Shell 的 echo 指令与 PHP 的 echo 指令类似，都是用于字符串的输出。命令格式： echo string 您可以使用echo实现更复杂的输出格式控制。 1.显示普通字符串: echo "It is a test" 这里的双引号完全可以省略，以下命令与上面实例效果一致： echo Itis a test 2.显示转义
  • Oracle DBA 简单操作 周凡杨 oracle dba sql
    --执行次数多的SQL select sql_text,executions from (      select sql_text,executions from v$sqlarea order by executions desc      ) where rownum<81;  &nb
  • 画图重绘 朱辉辉33 游戏
      我第一次接触重绘是编写五子棋小游戏的时候，因为游戏里的棋盘是用线绘制的，而这些东西并不在系统自带的重绘里，所以在移动窗体时，棋盘并不会重绘出来。所以我们要重写系统的重绘方法。   在重写系统重绘方法时，我们要注意一定要调用父类的重绘方法，即加上super.paint(g)，因为如果不调用父类的重绘方式，重写后会把父类的重绘覆盖掉，而父类的重绘方法是绘制画布，这样就导致我们
  • 线程之初体验 西蜀石兰 线程
    一直觉得多线程是学Java的一个分水岭，懂多线程才算入门。 之前看《编程思想》的多线程章节，看的云里雾里，知道线程类有哪几个方法，却依旧不知道线程到底是什么？书上都写线程是进程的模块，共享线程的资源，可是这跟多线程编程有毛线的关系，呜呜。。。 线程其实也是用户自定义的任务，不要过多的强调线程的属性，而忽略了线程最基本的属性。 你可以在线程类的run()方法中定义自己的任务，就跟正常的Ja
  • linux集群互相免登陆配置 林鹤霄 linux
    配置ssh免登陆 1、生成秘钥和公钥    ssh-keygen -t rsa 2、提示让你输入，什么都不输，三次回车之后会在~下面的.ssh文件夹中多出两个文件id_rsa 和 id_rsa.pub    其中id_rsa为秘钥，id_rsa.pub为公钥，使用公钥加密的数据只有私钥才能对这些数据解密    c
  • mysql : Lock wait timeout exceeded; try restarting transaction aigo mysql
    原文：http://www.cnblogs.com/freeliver54/archive/2010/09/30/1839042.html   原因是你使用的InnoDB   表类型的时候, 默认参数:innodb_lock_wait_timeout设置锁等待的时间是50s, 因为有的锁等待超过了这个时间,所以抱错.   你可以把这个时间加长,或者优化存储
  • Socket编程 基本的聊天实现。 alleni123 socket
    public class Server { //用来存储所有连接上来的客户 private List<ServerThread> clients; public static void main(String[] args) { Server s = new Server(); s.startServer(9988); } publi
  • 多线程监听器事件模式(一个简单的例子) 百合不是茶 线程监听模式
        多线程的事件监听器模式   监听器时间模式经常与多线程使用,在多线程中如何知道我的线程正在执行那什么内容,可以通过时间监听器模式得到        创建多线程的事件监听器模式 思路:    1, 创建线程并启动,在创建线程的位置设置一个标记     2,创建队
  • spring InitializingBean接口 bijian1013 javaspring
    spring的事务的TransactionTemplate，其源码如下： public class TransactionTemplate extends DefaultTransactionDefinition implements TransactionOperations, InitializingBean{ ... } TransactionTemplate继承了DefaultT
  • Oracle中询表的权限被授予给了哪些用户 bijian1013 oracle数据库权限
            Oracle查询表将权限赋给了哪些用户的SQL，以备查用。 select t.table_name as "表名", t.grantee as "被授权的属组", t.owner as "对象所在的属组"
  • 【Struts2五】Struts2 参数传值 bit1129 struts2
    Struts2中参数传值的3种情况 1.请求参数绑定到Action的实例字段上 2.Action将值传递到转发的视图上 3.Action将值传递到重定向的视图上   一、请求参数绑定到Action的实例字段上以及Action将值传递到转发的视图上 Struts可以自动将请求URL中的请求参数或者表单提交的参数绑定到Action定义的实例字段上，绑定的规则使用ognl表达式语言
  • 【Kafka十四】关于auto.offset.reset[Q/A] bit1129 kafka
    I got serveral questions about  auto.offset.reset. This configuration parameter governs how  consumer read the message from  Kafka when  there is no initial offset in ZooKeeper or
  • nginx gzip压缩配置 ronin47 nginx gzip 压缩范例
    nginx gzip压缩配置 更多 0 nginx gzip 配置   随着nginx的发展，越来越多的网站使用nginx，因此nginx的优化变得越来越重要，今天我们来看看nginx的gzip压缩到底是怎么压缩的呢？ gzip(GNU-ZIP)是一种压缩技术。经过gzip压缩后页面大小可以变为原来的30%甚至更小，这样，用
  • java-13.输入一个单向链表，输出该链表中倒数第 k 个节点 bylijinnan java
    two cursors. Make the first cursor go K steps first. /* * 第 13 题：题目：输入一个单向链表，输出该链表中倒数第 k 个节点 */ public void displayKthItemsBackWard(ListNode head,int k){ ListNode p1=head,p2=head;
  • Spring源码学习-JdbcTemplate queryForObject bylijinnan javaspring
    JdbcTemplate中有两个可能会混淆的queryForObject方法： 1. Object queryForObject(String sql, Object[] args, Class requiredType) 2. Object queryForObject(String sql, Object[] args, RowMapper rowMapper) 第1个方法是只查
  • [冰川时代]在冰川时代,我们需要什么样的技术? comsci 技术
         看美国那边的气候情况....我有个感觉...是不是要进入小冰期了?      那么在小冰期里面...我们的户外活动肯定会出现很多问题...在室内呆着的情况会非常多...怎么在室内呆着而不发闷...怎么用最低的电力保证室内的温度.....这都需要技术手段...   &nb
  • js 获取浏览器型号 cuityang js浏览器
    根据浏览器获取iphone和apk的下载地址 <!DOCTYPE html> <html> <head>     <meta charset="utf-8" content="text/html"/>     <meta name=
  • C# socks5详解 转 dalan_123 socketC#
    http://www.cnblogs.com/zhujiechang/archive/2008/10/21/1316308.html  这里主要讲的是用.NET实现基于Socket5下面的代理协议进行客户端的通讯，Socket4的实现是类似的，注意的事，这里不是讲用C#实现一个代理服务器，因为实现一个代理服务器需要实现很多协议，头大，而且现在市面上有很多现成的代理服务器用，性能又好，
  • 运维 Centos问题汇总 dcj3sjt126com 云主机
    一、sh 脚本不执行的原因 sh脚本不执行的原因 只有2个 1.权限不够 2.sh脚本里路径没写完整。   二、解决You have new mail in /var/spool/mail/root 修改/usr/share/logwatch/default.conf/logwatch.conf配置文件 MailTo = MailFrom   三、查询连接数
  • Yii防注入攻击笔记 dcj3sjt126com sqlWEB安全yii
    网站表单有注入漏洞须对所有用户输入的内容进行个过滤和检查，可以使用正则表达式或者直接输入字符判断，大部分是只允许输入字母和数字的，其它字符度不允许；对于内容复杂表单的内容，应该对html和script的符号进行转义替换：尤其是<,>,',"",&这几个符号 这里有个转义对照表： http://blog.csdn.net/xinzhu1990/articl
  • MongoDB简介[一] eksliang mongodbMongoDB简介
    MongoDB简介 转载请出自出处：http://eksliang.iteye.com/blog/2173288 1.1易于使用        MongoDB是一个面向文档的数据库，而不是关系型数据库。与关系型数据库相比，面向文档的数据库不再有行的概念，取而代之的是更为灵活的“文档”模型。        另外，不
  • zookeeper windows 入门安装和测试 greemranqq zookeeper安装分布式
    一、序言       以下是我对zookeeper 的一些理解：      zookeeper 作为一个服务注册信息存储的管理工具，好吧，这样说得很抽象，我们举个“栗子”。       栗子1号：       假设我是一家KTV的老板，我同时拥有5家KTV，我肯定得时刻监视
  • Spring之使用事务缘由(2-注解实现) ihuning spring
      Spring事务注解实现   1. 依赖包：     1.1 spring包：           spring-beans-4.0.0.RELEASE.jar           spring-context-4.0.0.
  • iOS App Launch Option 啸笑天 option
    iOS 程序启动时总会调用application:didFinishLaunchingWithOptions:，其中第二个参数launchOptions为NSDictionary类型的对象，里面存储有此程序启动的原因。   launchOptions中的可能键值见UIApplication Class Reference的Launch Options Keys节 。 1、若用户直接
  • jdk与jre的区别（_） macroli javajvmjdk
    简单的说JDK是面向开发人员使用的SDK，它提供了Java的开发环境和运行环境。SDK是Software Development Kit 一般指软件开发包，可以包括函数库、编译程序等。  JDK就是Java Development Kit JRE是Java Runtime Enviroment是指Java的运行环境，是面向Java程序的使用者，而不是开发者。 如果安装了JDK，会发同你
  • Updates were rejected because the tip of your current branch is behind qiaolevip 学习永无止境每天进步一点点众观千象git
    $ git push joe prod-2295-1 To [email protected]:joe.le/dr-frontend.git ! [rejected] prod-2295-1 -> prod-2295-1 (non-fast-forward) error: failed to push some refs to '[email protected]
  • [一起学Hive]之十四-Hive的元数据表结构详解 superlxw1234 hivehive元数据结构
    关键字：Hive元数据、Hive元数据表结构   之前在 “[一起学Hive]之一–Hive概述，Hive是什么”中介绍过，Hive自己维护了一套元数据，用户通过HQL查询时候，Hive首先需要结合元数据，将HQL翻译成MapReduce去执行。 本文介绍一下Hive元数据中重要的一些表结构及用途，以Hive0.13为例。   文章最后面，会以一个示例来全面了解一下，
  • Spring 3.2.14，4.1.7，4.2.RC2发布 wiselyman Spring 3
      Spring 3.2.14、4.1.7及4.2.RC2于6月30日发布。   其中Spring 3.2.1是一个维护版本(维护周期到2016-12-31截止)，后续会继续根据需求和bug发布维护版本。此时，Spring官方强烈建议升级Spring框架至4.1.7 或者将要发布的4.2 。   其中Spring 4.1.7主要包含这些更新内容。
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他