01_lombok & review

Lombok

怎么引入Lombok依赖：

• step1：引入Lombok依赖

eg：

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

• step2：安装Lombok插件
  
• step3：使用
  • @Data：注解在类上；提供类所有属性的 getting 和 setting 方法，此外还提供了equals、canEqual、hashCode、toString 方法
  • @AllArgsConstructor：全部参数的有参构造方法
  • @NoArgsConstructor：无参构造方法

eg：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private Integer id;
    private String username;
    private String password;
}

---

父子工程

• 父工程提供通用的依赖
  
• 父工程的特点：
  • packaging标签的值：pom，在编译之后只有一个pom文件，所以在这个文件里面不写代码、不写配置文件
  • 通用的配置：主要是依赖
    • 父工程中的dependencies和dependencyManagement之间的区别：
      • dependencies：给子工程特供依赖
      • dependencyManagement：给子工程提供依赖 的版本
        • 如果子工程中引入了这个依赖，可以不写版本号；如果子工程中写了版本号，以子工程为准
    • 子工程中引入mysql驱动依赖，可以不写版本，只要父工程dependencyManagement声明版本号即可

eg：

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
    </dependencies>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.47</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

---

ide中的Maven基础配置

• Maven 根路径
• setting.xml
  • mirror镜像：阿里云的镜像仓库
  • profile：jdk版本
• 本地仓库
  

常见问题：

• 打开其他人的项目（project）-> .idea文件夹所在的文件 -> 先要settings

---

前置知识储备

• 抽象部分：为什么使用接口或抽象类，在什么情况下使用接口，什么情况下使用抽象类
  • 规范：方法名、形参（个数、类型）、返回值类型
  • 抽象类做类似的事情 方法定义为抽象方法，抽象类的子类必须要实现抽象方法
  • 个性化和通用性 兼得 就可以使用抽象类
• 静态内部类的类加载过程
  • 没有使用到静态内部类，它没有加载
• 匿名内部类的定义和使用
  • new 接口或抽象类
  • 完成了类的定义，并且获得了实例
  • 如果要使用外部的局部变量的时候，使用匿名内部类可以直接获取
• 反射：反射过程中的常用名词Class、Field、Method、Parameter、Constructor。
  • 反射过程中的常用方法：
    • 获得class、field、method、parameter、constructor → getDeclaredXXX
    • 通过反射获得实例 class和constructor
    • 通过反射调用方法 method.invoke(instance,args)

eg：

public class Reflect {
    public static void main(String[] args)
            throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException,
            InvocationTargetException, InstantiationException, IllegalAccessException {
        // 没有使用反射
        execute1();

        // 使用反射
        execute2();

        // 使用反射的方式重写execute1()
        execute3();

        // 工具类加载配置文件
        execute4();
    }

    private static void execute4() {
        ExecuteUtil.execute("execute.properties",new Object[]{"zs"});
    }

    private static void execute3()
            throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException,
            InstantiationException, IllegalAccessException, NoSuchFieldException {
        Class<?> aClass = Class.forName("com.coo1heisenberg.Demo1.UserService");

        Constructor<?> constructor = aClass.getDeclaredConstructor();

        // 1. 调用构造器获得一个实例
        Object instance = constructor.newInstance();

        // 或者
        Object instance1 = aClass.newInstance();

        // 2. 给username这个成员变量field赋值
        Field field = aClass.getDeclaredField("username");
        // 避免成员变量权限不足
        field.setAccessible(true);
        field.set(instance, "zs");

        // 3. 调用instance对象的eatTogether方法
        Method method = aClass.getDeclaredMethod("eatTogether", String.class);
        String name = "ls";
        Object[] args = new Object[]{name};
        method.invoke(instance, args);
    }

    private static void execute2()
            throws ClassNotFoundException, NoSuchFieldException, NoSuchMethodException {
        // 1. Class对象获取方式

        // 常用
        Class clazz1 = UserService.class;

        UserService userService = new UserService();
        Class clazz2 = userService.getClass();

        // 常用
        Class clazz3 = Class.forName("com.coo1heisenberg.Demo1.UserService");

        Class clazz4 = clazz2.getClassLoader()
        .loadClass("com.coo1heisenberg.Demo1.UserService");

        // 2. 获得里面的Field
        Field field = clazz3.getDeclaredField("username");
        Field[] declaredFields = clazz3.getDeclaredFields();

        // 3. Method
        Method[] declaredMethods = clazz3.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            boolean eatTogether = declaredMethod.getName().equals("eatTogether");
            System.out.println(eatTogether);
        }
        Method ww = clazz3.getDeclaredMethod("eatTogether", String.class);
        System.out.println(ww);

        // 4. constructor
        Constructor[] declaredConstructors = clazz3.getDeclaredConstructors();

    }

    private static void execute1() {
        UserService userService = new UserService();
        userService.setUsername("zs");
        userService.eatTogether("ls");
    }
}



public class ExecuteUtil {
    // args = new Object[]{zs}
    public static void execute(String fileName, Object args) {
        // getClassLoader是为了加载class下的配置文件
        InputStream inputStream = ExecuteUtil.class.getClassLoader()
        .getResourceAsStream(fileName);
        Properties properties = new Properties();
        try {
            properties.load(inputStream);
            String className = properties.getProperty("className");
            String methodName = properties.getProperty("methodName");
            String fieldName = properties.getProperty("fieldName");
            String fieldValue = properties.getProperty("fieldValue");

            Class<?> aClass = Class.forName(className);
//            aClass.getDeclaredMethod(methodName,String.class);
            Method method = null;
            Method[] declaredMethods = aClass.getDeclaredMethods();
            for (Method declaredMethod : declaredMethods) {
                if(methodName.equals(declaredMethod.getName())){
                    method = declaredMethod;
                }
            }

            Object instance = aClass.newInstance();
            Field declaredField = aClass.getDeclaredField(fieldName);
            declaredField.setAccessible(true);
            declaredField.set(instance,fieldValue);

            method.invoke(instance, args);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}


@Data
public class UserService {
    String username;
    public void eatTogether(String name){
        String result = username + name + "go out to eat";
        System.out.println(result);
    }
}

---