文章目录
- Lombok
- 父子工程
- ide中的Maven基础配置
- 前置知识储备
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);
}
}
