关于java:我在上海乐字节学习的第二十四天持续更新中

5次阅读

共计 26057 个字符，预计需要花费 66 分钟才能阅读完成。

代理对象存在的价值：次要用于拦挡对实在业务对象的拜访。
代理对象有什么办法？
当初要生成某一个对象的代理对象，这个代理对象通常也要编写一个类来生成，所以首先要编写用于生成代理对象的类。
如何编写生成代理对象的类，两个因素：
代理谁
如何生成代理对象
代理谁？
设计一个类变量，以及一个构造函数，记住代理类代理哪个对象。
如何生成代理对象？
设计一个办法生成代理对象（在办法内编写代码生成代理对象是此处编程的难点）
Java 提供了一个 Proxy 类，调用它的 newInstance 办法能够生成某个对象的代理对象，应用该办法生成代理对象时，须要三个参数：
1. 生成代理对象应用哪个类装载器
2. 生成哪个对象的代理对象，通过接口指定
3. 生成的代理对象的办法里干什么事，由开发人员编写 handler 接口的实现来指定。
初学者必须必须记住的 2 件事件：
Proxy 类负责创立代理对象时，如果指定了 handler（处理器），那么不论用户调用代理对象的什么办法，该办法都是调用处理器的 invoke 办法。
因为 invoke 办法被调用须要三个参数：代理对象、办法、办法的参数，因而不论代理对象哪个办法调用处理器的 invoke 办法，都必须把本人所在的对象、本人（调用 invoke 办法的办法）、办法的参数传递进来。

代理模式作用:
屏蔽实在行为的拜访，让程序更加平安。
能够对实在行为的调用进行管制。
通过一个案例：来阐明代理的实现以及代理的作用
代理模式实现:
1. 代理类与被代理类要实现同一个接口.

// 潘金莲 — 被代理

public class Pjl implements KindWoman{

public void throwEye(){

System.out.println(“ 潘金莲抛媚眼 ”);

}

public void doSomething(){

System.out.println(“ 潘金莲。。。。。。。。”);

}

}

// 王婆 — 代理

public class Wp implements KindWoman {

private KindWoman woman;

public Wp(KindWoman woman) {

this.woman = woman;

}

public void throwEye() {

woman.throwEye();

}

public void doSomething() {

woman.doSomething();

}

}

2. 在代理类中持有被代理对象.

public class Xmq {

public static void main(String[] args) {

KindWoman woman = new Pjl();

Wp wp = new Wp(woman);

wp.throwEye();// 实在执行的是潘金莲，然而咱们看不到，所以屏蔽了实在行为。

}

}

3. 在代理类中调用被代理的行为。

public void throwEye() {

// 在这里做操作，能够管制是否调用实在行为。

woman.throwEye();

// 在这个地位，能够在实在行为调用实现后，在做操作。

}

public void doSomething() {

woman.doSomething();

}

}

AOP 的底层实现就是通过 动静代理 来做到的。
动静代理
在代理模式根底上倒退的，它不在是对繁多的类型进行代理，而是能够对任意的一个实现了接口的类的对象做代理。

两种形式:
这种形式要求，被代理类必须实现接口，即只能为接口做代理.
1. 通过 jdk 中提供的 Proxy 类来实现
2. 通过 cglib 来实现，它不要求实现接口。
第一种形式的代码实现:
loader: 要求，传递的是 被代理类 的类加载器 ClassLoader
interfaces: 要求: 失去 被代理对象 所实现的接口的所有Class 对象。
h: 它的类型是 InvocationHandler，这是一个接口。
失去其 Class 对象，在 Class 类中提供一个办法 getClassLoader();
类加载器怎么获取:
失去其 Class 对象，在 Class 类中提供一个办法 getInterfaces(); 它返回的是 Class[], 就代表所实现接口的所有 Class 对象。
怎么获取所有实现接口的 Class 对象?
InvocationHandler 是代理实例的 调用处理程序 实现的接口。
Proxy 类中有一个办法 newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h);
参数:
InvocationHandler接口中有一个办法invoke;
public Object invoke(Object proxy, Method method, Object[] args);
参数 proxy 就是 代理对象
参数 method 就是 调用办法
参数 args 就是调用的 办法的参数
返回值, 就是实在行为执行后返回的后果，会传递给代理对象调用的办法.
eg：

public class Student implements Person {

public String say(String message) {

return “hello ” + message;

}

}

public class StudentProxyTest {

public static void main(String[] args) {

// 做 Person 接口实现类 Student 的动静代理。

// 1. 创立一个 Student 被代理

final Person s = new Student();

// 2. 失去 s 的代理对象.

Person sproxy = (Person) Proxy.newProxyInstance(s.getClass()

.getClassLoader(), s.getClass().getInterfaces(),

new InvocationHandler() {

// 参数 proxy 就是代理对象

// 参数 method 就是调用办法

// 参数 args 就是调用的办法的参数

// 返回值, 就是实在行为执行后返回的后果，会传递给代理对象调用的办法.

public Object invoke(Object proxy, Method method,

Object[] args) throws Throwable {

// proxy, 就是代理对象，咱们个别不应用。

// method, 就是要拜访的办法。

// args 就是要拜访的办法的参数

return method.invoke(s, args); // s.say(“james”);

}

});

String message = sproxy.say(“james”); // 这个是代理对象调用 say 办法.

System.out.println(message);

}

}

public class LoginServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String username = request.getParameter(“username”);

System.out.println(username);

}

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

doGet(request, response);

}

}

2. 操作

public class EncodingFilter implements Filter {

public void init(FilterConfig filterConfig) throws ServletException {

}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

// 1. 强转

final HttpServletRequest req = (HttpServletRequest) request;

HttpServletResponse resp = (HttpServletResponse) response;

// 2. 操作

// 创立一个 req 对象的代理对象 reqProxy

HttpServletRequest reqProxy = (HttpServletRequest) Proxy

.newProxyInstance(req.getClass().getClassLoader(), req

.getClass().getInterfaces(), new InvocationHandler() {

public Object invoke(Object proxy, Method method,

Object[] args) throws Throwable {

// 1. 失去办法名称

String methodName = method.getName();

if (“getParameter”.equals(methodName)) {

String param = req.getParameter((String) (args[0]));

return new String(param.getBytes(“iso8859-1”),

“utf-8”);

} else {

// 不是 getParameter 办法，就执行其原来操作.

return method.invoke(req, args);

}

}

});

// 3. 放行

chain.doFilter(reqProxy, resp);

}

public void destroy() {

}

}

数据库

create table users(

id int primary key auto_increment,

username varchar(40),

password varchar(40)

);

insert into users values(null,’aaa’,’111′);

insert into users values(null,’bbb’,’111′);

insert into users values(null,’ccc’,’111′);

create table privileges(

id int primary key auto_increment,

name varchar(40)

);

insert into privileges values(null,’ 增加图书 ’);

insert into privileges values(null,’ 批改图书 ’);

insert into privileges values(null,’ 查看图书 ’);

insert into privileges values(null,’ 删除图书 ’);

多对多表关系

create table userprivilege(

user_id int ,

privilege_id int,

foreign key(user_id) references users(id),

foreign key(privilege_id) references privileges(id),

primary key(user_id,privilege_id)

);

insert into userprivilege values(1,1);

代码实现:
1. 实现登录操作，将 user 存储到 session 中.
login.jsp LoginServlet UserService UserDao.
2. 登录胜利，跳转到 book.jsp 页面。
能够通过在申请，携带参数来判断要做什么操作
在这个页面上有四个超连贯，拜访的是同一个 servlet（BookServlet）
问题: 怎么让一个 servlet 解决多个申请？

book add

book update

book delete

book search

在 servlet 中判断 method 值是什么，调用不同的申请解决办法.
这种形式下，在做权限管制时，如果应用 url 级别权限管制，就不能通过判断申请的资源门路来解决。
能够应用细粒度权限管制:
实现原理: 应用注解 + 动静代理来实现。
注解: 它用于定义以后行为的拜访须要什么权限。
动静代理帮忙咱们实现管制拦挡。简略说，就是在代理中，会判断以后用户是否具备拜访该行为的权限, 如果有会调用被代理的行为，如果没有，不调用行为，间接抛出权限有余。
3. 实现权限管制
1. 创立一个 BookInfo 注解，它是用于形容行为拜访时，须要什么权限的.

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

@Inherited

public @interface BookInfo {

String value(); // 这就是权限名称

}

2. 在 BookServiceFactory 中进行权限管制

1. 失去以后行为拜访须要的权限名称
BookInfo bif = method.getAnnotation(BookInfo.class);
String pname = bif.value();
2. 失去以后登录的用户
User user = (User) args[0];
咱们在所有的 service 的办法上增加了一个 User 参数。
那么咱们获取时，就能够间接通过 invoke 办法的 args 参数获取.
1. 首先判断用户是否存在，也就是判断它是否登录了。

User user = (User) args[0];

if (user == null) {

throw new RuntimeException(“ 没有登录，请登录后操作 ”);

}

2. 如果登录了，依据用户查询数据库，失去这个用户所具备的所有权限名称

* 应用 ColumnListHandler 进行封装查问后果。

SELECT

privileges.name

FROM

users,PRIVILEGES,userprivilege

WHERE

users.id=userprivilege.user_id

AND

privileges.id=userprivilege.privilege_id

AND

users.id=?”;

QueryRunner runner = new QueryRunner(DataSourceUtils

.getDataSource());

List<Object> pnames = runner.query(sql,

new ColumnListHandler(), user.getId());

判断用户是否具备权限

// 实在行为拜访前 – 判断用户是否有权限执行以后行为

boolean flag = method.isAnnotationPresent(BookInfo.class);

if (!flag) {

// 不须要权限

return method.invoke(service, args);

}

if (pnames.contains(pname)) {

Object obj = method.invoke(service, args);

// 实在行为拜访后

return obj;

} else {

throw new RuntimeException(“ 权限有余 ”);

什么是类加载器，有什么作用?
1. 疏导类加载器 BootStrap jre/lib/rt.jar
2. 扩大类加载器 ExtClassLoader JRE/lib/ext/*.jar
3. 利用类加载器(零碎类加载器) AppClassLoader SystemClassLoader CLASSPATH 指定的所有 jar 或目录
类加载器的作用就是将 java 中的字节码文件 (.class 文件) 转换成 Class 对象。
当 JVM 启动时，会造成由三个类加载器组成的初始类加载器层次结构：
在 java 中 ClassLoader 代表类加载器，所有的类加载器都是 ClassLoader 的子.
bootstrap classloader：疏导（也称为原始）类加载器，它负责加载 Java 的外围类。这个加载器的是十分非凡的，它实际上不是 java.lang.ClassLoader 的子类，而是由 JVM 本身实现的。能够通过执行以下代码来取得 bootstrap classloader 加载了那些外围类库：

URL[] urls=sun.misc.Launcher.getBootstrapClassPath().getURLs();

for (int i = 0; i < urls.length; i++) {

System.out.println(urls[i].toExternalForm());

}

因为 JVM 在启动的时候就主动加载它们, 所以不须要在零碎属性 CLASSPATH 中指定这些类库
演示类加载器
在 Class 类中有一个办法 getClassLoader()它返回的就是一个类加载器.
问题: 类加载器如果获取?
1. 获取疏导类加载器
ClassLoader cl = String.class.getClassLoader();
System.out.println(cl);
后果是 null.
起因: 疏导类加载器非凡，它基本就不是 java 实现。所有在失去疏导类回载器是后果就是 null.
2. 扩大类加载器
ClassLoader cl = AccessBridge.class.getClassLoader();
System.out.println(cl); //sun.misc.Launcher$ExtClassLoader@9cb0f4
3. 利用类加载器
ClassLoader cl = this.getClass().getClassLoader();
System.out.println(cl); //sun.misc.Launcher$AppClassLoader@164dbd5

全盘负责：即是当一个 classloader 加载一个 Class 的时候，这个 Class 所依赖的和援用的其它 Class 通常也由这个 classloader 负责载入。
委托机制：先让 parent（父）类加载器寻找，只有在 parent 找不到的时候才从本人的类门路中去寻找。
类加载还采纳了 cache 机制：如果 cache 中保留了这个 Class 就间接返回它，如果没有才从文件中读取和转换成 Class，并存入 cache，这就是为什么批改了 Class 然而必须重新启动 JVM 能力失效, 并且类只加载一次的起因。

创立了一个类 javax.activation.MimeType，在这个类中有一个办法 show(); 当 jvm 加载这个类时，因为在 rt.jar 包下也存在一个 MimeType 类，并且包名都一样，这时 jvm 就会应用疏导类加载器加载这个类，而咱们想得到的其实是应该由利用类加载器加载的 Class.
解决方案: 自定义类加载器.
1. 创立一个类，去继承自 ClassLoader
2. 重写 findClass 办法，在这个办法中通过 defineClass 将一个.class 文件转换成 Class 对象.

泛型反射

代理对象存在的价值：次要用于拦挡对实在业务对象的拜访。
代理对象有什么办法？
当初要生成某一个对象的代理对象，这个代理对象通常也要编写一个类来生成，所以首先要编写用于生成代理对象的类。
如何编写生成代理对象的类，两个因素：
代理谁
如何生成代理对象
代理谁？
设计一个类变量，以及一个构造函数，记住代理类代理哪个对象。
如何生成代理对象？
设计一个办法生成代理对象（在办法内编写代码生成代理对象是此处编程的难点）
Java 提供了一个 Proxy 类，调用它的 newInstance 办法能够生成某个对象的代理对象，应用该办法生成代理对象时，须要三个参数：
1. 生成代理对象应用哪个类装载器
2. 生成哪个对象的代理对象，通过接口指定
3. 生成的代理对象的办法里干什么事，由开发人员编写 handler 接口的实现来指定。
初学者必须必须记住的 2 件事件：
Proxy 类负责创立代理对象时，如果指定了 handler（处理器），那么不论用户调用代理对象的什么办法，该办法都是调用处理器的 invoke 办法。
因为 invoke 办法被调用须要三个参数：代理对象、办法、办法的参数，因而不论代理对象哪个办法调用处理器的 invoke 办法，都必须把本人所在的对象、本人（调用 invoke 办法的办法）、办法的参数传递进来。

代理模式作用:
屏蔽实在行为的拜访，让程序更加平安。
能够对实在行为的调用进行管制。
通过一个案例：来阐明代理的实现以及代理的作用
代理模式实现:
1. 代理类与被代理类要实现同一个接口.

// 潘金莲 — 被代理

public class Pjl implements KindWoman{

public void throwEye(){

System.out.println(“ 潘金莲抛媚眼 ”);

}

public void doSomething(){

System.out.println(“ 潘金莲。。。。。。。。”);

}

}

// 王婆 — 代理

public class Wp implements KindWoman {

private KindWoman woman;

public Wp(KindWoman woman) {

this.woman = woman;

}

public void throwEye() {

woman.throwEye();

}

public void doSomething() {

woman.doSomething();

}

}

2. 在代理类中持有被代理对象.

public class Xmq {

public static void main(String[] args) {

KindWoman woman = new Pjl();

Wp wp = new Wp(woman);

wp.throwEye();// 实在执行的是潘金莲，然而咱们看不到，所以屏蔽了实在行为。

}

}

3. 在代理类中调用被代理的行为。

public void throwEye() {

// 在这里做操作，能够管制是否调用实在行为。

woman.throwEye();

// 在这个地位，能够在实在行为调用实现后，在做操作。

}

public void doSomething() {

woman.doSomething();

}

}

AOP 的底层实现就是通过 动静代理 来做到的。
动静代理
在代理模式根底上倒退的，它不在是对繁多的类型进行代理，而是能够对任意的一个实现了接口的类的对象做代理。

两种形式:
这种形式要求，被代理类必须实现接口，即只能为接口做代理.
1. 通过 jdk 中提供的 Proxy 类来实现
2. 通过 cglib 来实现，它不要求实现接口。
第一种形式的代码实现:
loader: 要求，传递的是 被代理类 的类加载器 ClassLoader
interfaces: 要求: 失去 被代理对象 所实现的接口的所有Class 对象。
h: 它的类型是 InvocationHandler，这是一个接口。
失去其 Class 对象，在 Class 类中提供一个办法 getClassLoader();
类加载器怎么获取:
失去其 Class 对象，在 Class 类中提供一个办法 getInterfaces(); 它返回的是 Class[], 就代表所实现接口的所有 Class 对象。
怎么获取所有实现接口的 Class 对象?
InvocationHandler 是代理实例的 调用处理程序 实现的接口。
Proxy 类中有一个办法 newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h);
参数:
InvocationHandler接口中有一个办法invoke;
public Object invoke(Object proxy, Method method, Object[] args);
参数 proxy 就是 代理对象
参数 method 就是 调用办法
参数 args 就是调用的 办法的参数
返回值, 就是实在行为执行后返回的后果，会传递给代理对象调用的办法.
eg：

public class Student implements Person {

public String say(String message) {

return “hello ” + message;

}

}

public class StudentProxyTest {

public static void main(String[] args) {

// 做 Person 接口实现类 Student 的动静代理。

// 1. 创立一个 Student 被代理

final Person s = new Student();

// 2. 失去 s 的代理对象.

Person sproxy = (Person) Proxy.newProxyInstance(s.getClass()

.getClassLoader(), s.getClass().getInterfaces(),

new InvocationHandler() {

// 参数 proxy 就是代理对象

// 参数 method 就是调用办法

// 参数 args 就是调用的办法的参数

// 返回值, 就是实在行为执行后返回的后果，会传递给代理对象调用的办法.

public Object invoke(Object proxy, Method method,

Object[] args) throws Throwable {

// proxy, 就是代理对象，咱们个别不应用。

// method, 就是要拜访的办法。

// args 就是要拜访的办法的参数

return method.invoke(s, args); // s.say(“james”);

}

});

String message = sproxy.say(“james”); // 这个是代理对象调用 say 办法.

System.out.println(message);

}

}

public class LoginServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String username = request.getParameter(“username”);

System.out.println(username);

}

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

doGet(request, response);

}

}

2. 操作

public class EncodingFilter implements Filter {

public void init(FilterConfig filterConfig) throws ServletException {

}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

// 1. 强转

final HttpServletRequest req = (HttpServletRequest) request;

HttpServletResponse resp = (HttpServletResponse) response;

// 2. 操作

// 创立一个 req 对象的代理对象 reqProxy

HttpServletRequest reqProxy = (HttpServletRequest) Proxy

.newProxyInstance(req.getClass().getClassLoader(), req

.getClass().getInterfaces(), new InvocationHandler() {

public Object invoke(Object proxy, Method method,

Object[] args) throws Throwable {

// 1. 失去办法名称

String methodName = method.getName();

if (“getParameter”.equals(methodName)) {

String param = req.getParameter((String) (args[0]));

return new String(param.getBytes(“iso8859-1”),

“utf-8”);

} else {

// 不是 getParameter 办法，就执行其原来操作.

return method.invoke(req, args);

}

}

});

// 3. 放行

chain.doFilter(reqProxy, resp);

}

public void destroy() {

}

}

数据库

create table users(

id int primary key auto_increment,

username varchar(40),

password varchar(40)

);

insert into users values(null,’aaa’,’111′);

insert into users values(null,’bbb’,’111′);

insert into users values(null,’ccc’,’111′);

create table privileges(

id int primary key auto_increment,

name varchar(40)

);

insert into privileges values(null,’ 增加图书 ’);

insert into privileges values(null,’ 批改图书 ’);

insert into privileges values(null,’ 查看图书 ’);

insert into privileges values(null,’ 删除图书 ’);

多对多表关系

create table userprivilege(

user_id int ,

privilege_id int,

foreign key(user_id) references users(id),

foreign key(privilege_id) references privileges(id),

primary key(user_id,privilege_id)

);

insert into userprivilege values(1,1);

代码实现:
1. 实现登录操作，将 user 存储到 session 中.
login.jsp LoginServlet UserService UserDao.
2. 登录胜利，跳转到 book.jsp 页面。
能够通过在申请，携带参数来判断要做什么操作
在这个页面上有四个超连贯，拜访的是同一个 servlet（BookServlet）
问题: 怎么让一个 servlet 解决多个申请？

book add

book update

book delete

book search

在 servlet 中判断 method 值是什么，调用不同的申请解决办法.
这种形式下，在做权限管制时，如果应用 url 级别权限管制，就不能通过判断申请的资源门路来解决。
能够应用细粒度权限管制:
实现原理: 应用注解 + 动静代理来实现。
注解: 它用于定义以后行为的拜访须要什么权限。
动静代理帮忙咱们实现管制拦挡。简略说，就是在代理中，会判断以后用户是否具备拜访该行为的权限, 如果有会调用被代理的行为，如果没有，不调用行为，间接抛出权限有余。
3. 实现权限管制
1. 创立一个 BookInfo 注解，它是用于形容行为拜访时，须要什么权限的.

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

@Inherited

public @interface BookInfo {

String value(); // 这就是权限名称

}

2. 在 BookServiceFactory 中进行权限管制

1. 失去以后行为拜访须要的权限名称
BookInfo bif = method.getAnnotation(BookInfo.class);
String pname = bif.value();
2. 失去以后登录的用户
User user = (User) args[0];
咱们在所有的 service 的办法上增加了一个 User 参数。
那么咱们获取时，就能够间接通过 invoke 办法的 args 参数获取.
1. 首先判断用户是否存在，也就是判断它是否登录了。

User user = (User) args[0];

if (user == null) {

throw new RuntimeException(“ 没有登录，请登录后操作 ”);

}

2. 如果登录了，依据用户查询数据库，失去这个用户所具备的所有权限名称

* 应用 ColumnListHandler 进行封装查问后果。

SELECT

privileges.name

FROM

users,PRIVILEGES,userprivilege

WHERE

users.id=userprivilege.user_id

AND

privileges.id=userprivilege.privilege_id

AND

users.id=?”;

QueryRunner runner = new QueryRunner(DataSourceUtils

.getDataSource());

List<Object> pnames = runner.query(sql,

new ColumnListHandler(), user.getId());

判断用户是否具备权限

// 实在行为拜访前 – 判断用户是否有权限执行以后行为

boolean flag = method.isAnnotationPresent(BookInfo.class);

if (!flag) {

// 不须要权限

return method.invoke(service, args);

}

if (pnames.contains(pname)) {

Object obj = method.invoke(service, args);

// 实在行为拜访后

return obj;

} else {

throw new RuntimeException(“ 权限有余 ”);

什么是类加载器，有什么作用?
1. 疏导类加载器 BootStrap jre/lib/rt.jar
2. 扩大类加载器 ExtClassLoader JRE/lib/ext/*.jar
3. 利用类加载器(零碎类加载器) AppClassLoader SystemClassLoader CLASSPATH 指定的所有 jar 或目录
类加载器的作用就是将 java 中的字节码文件 (.class 文件) 转换成 Class 对象。
当 JVM 启动时，会造成由三个类加载器组成的初始类加载器层次结构：
在 java 中 ClassLoader 代表类加载器，所有的类加载器都是 ClassLoader 的子.
bootstrap classloader：疏导（也称为原始）类加载器，它负责加载 Java 的外围类。这个加载器的是十分非凡的，它实际上不是 java.lang.ClassLoader 的子类，而是由 JVM 本身实现的。能够通过执行以下代码来取得 bootstrap classloader 加载了那些外围类库：

URL[] urls=sun.misc.Launcher.getBootstrapClassPath().getURLs();

for (int i = 0; i < urls.length; i++) {

System.out.println(urls[i].toExternalForm());

}

因为 JVM 在启动的时候就主动加载它们, 所以不须要在零碎属性 CLASSPATH 中指定这些类库
演示类加载器
在 Class 类中有一个办法 getClassLoader()它返回的就是一个类加载器.
问题: 类加载器如果获取?
1. 获取疏导类加载器
ClassLoader cl = String.class.getClassLoader();
System.out.println(cl);
后果是 null.
起因: 疏导类加载器非凡，它基本就不是 java 实现。所有在失去疏导类回载器是后果就是 null.
2. 扩大类加载器
ClassLoader cl = AccessBridge.class.getClassLoader();
System.out.println(cl); //sun.misc.Launcher$ExtClassLoader@9cb0f4
3. 利用类加载器
ClassLoader cl = this.getClass().getClassLoader();
System.out.println(cl); //sun.misc.Launcher$AppClassLoader@164dbd5

全盘负责：即是当一个 classloader 加载一个 Class 的时候，这个 Class 所依赖的和援用的其它 Class 通常也由这个 classloader 负责载入。
委托机制：先让 parent（父）类加载器寻找，只有在 parent 找不到的时候才从本人的类门路中去寻找。
类加载还采纳了 cache 机制：如果 cache 中保留了这个 Class 就间接返回它，如果没有才从文件中读取和转换成 Class，并存入 cache，这就是为什么批改了 Class 然而必须重新启动 JVM 能力失效, 并且类只加载一次的起因。

创立了一个类 javax.activation.MimeType，在这个类中有一个办法 show(); 当 jvm 加载这个类时，因为在 rt.jar 包下也存在一个 MimeType 类，并且包名都一样，这时 jvm 就会应用疏导类加载器加载这个类，而咱们想得到的其实是应该由利用类加载器加载的 Class.
解决方案: 自定义类加载器.
1. 创立一个类，去继承自 ClassLoader
2. 重写 findClass 办法，在这个办法中通过 defineClass 将一个.class 文件转换成 Class 对象.

问题: 在 BaseDaoImpl 类动静代理

====

代理对象存在的价值：次要用于拦挡对实在业务对象的拜访。
代理对象有什么办法？
当初要生成某一个对象的代理对象，这个代理对象通常也要编写一个类来生成，所以首先要编写用于生成代理对象的类。
如何编写生成代理对象的类，两个因素：
代理谁
如何生成代理对象
代理谁？
设计一个类变量，以及一个构造函数，记住代理类代理哪个对象。
如何生成代理对象？
设计一个办法生成代理对象（在办法内编写代码生成代理对象是此处编程的难点）
Java 提供了一个 Proxy 类，调用它的 newInstance 办法能够生成某个对象的代理对象，应用该办法生成代理对象时，须要三个参数：
1. 生成代理对象应用哪个类装载器
2. 生成哪个对象的代理对象，通过接口指定
3. 生成的代理对象的办法里干什么事，由开发人员编写 handler 接口的实现来指定。
初学者必须必须记住的 2 件事件：
Proxy 类负责创立代理对象时，如果指定了 handler（处理器），那么不论用户调用代理对象的什么办法，该办法都是调用处理器的 invoke 办法。
因为 invoke 办法被调用须要三个参数：代理对象、办法、办法的参数，因而不论代理对象哪个办法调用处理器的 invoke 办法，都必须把本人所在的对象、本人（调用 invoke 办法的办法）、办法的参数传递进来。

代理模式作用:
屏蔽实在行为的拜访，让程序更加平安。
能够对实在行为的调用进行管制。
通过一个案例：来阐明代理的实现以及代理的作用
代理模式实现:
1. 代理类与被代理类要实现同一个接口.

// 潘金莲 — 被代理

public class Pjl implements KindWoman{

public void throwEye(){

System.out.println(“ 潘金莲抛媚眼 ”);

}

public void doSomething(){

System.out.println(“ 潘金莲。。。。。。。。”);

}

}

// 王婆 — 代理

public class Wp implements KindWoman {

private KindWoman woman;

public Wp(KindWoman woman) {

this.woman = woman;

}

public void throwEye() {

woman.throwEye();

}

public void doSomething() {

woman.doSomething();

}

}

2. 在代理类中持有被代理对象.

public class Xmq {

public static void main(String[] args) {

KindWoman woman = new Pjl();

Wp wp = new Wp(woman);

wp.throwEye();// 实在执行的是潘金莲，然而咱们看不到，所以屏蔽了实在行为。

}

}

3. 在代理类中调用被代理的行为。

public void throwEye() {

// 在这里做操作，能够管制是否调用实在行为。

woman.throwEye();

// 在这个地位，能够在实在行为调用实现后，在做操作。

}

public void doSomething() {

woman.doSomething();

}

}

AOP 的底层实现就是通过 动静代理 来做到的。
动静代理
在代理模式根底上倒退的，它不在是对繁多的类型进行代理，而是能够对任意的一个实现了接口的类的对象做代理。

两种形式:
这种形式要求，被代理类必须实现接口，即只能为接口做代理.
1. 通过 jdk 中提供的 Proxy 类来实现
2. 通过 cglib 来实现，它不要求实现接口。
第一种形式的代码实现:
loader: 要求，传递的是 被代理类 的类加载器 ClassLoader
interfaces: 要求: 失去 被代理对象 所实现的接口的所有Class 对象。
h: 它的类型是 InvocationHandler，这是一个接口。
失去其 Class 对象，在 Class 类中提供一个办法 getClassLoader();
类加载器怎么获取:
失去其 Class 对象，在 Class 类中提供一个办法 getInterfaces(); 它返回的是 Class[], 就代表所实现接口的所有 Class 对象。
怎么获取所有实现接口的 Class 对象?
InvocationHandler 是代理实例的 调用处理程序 实现的接口。
Proxy 类中有一个办法 newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h);
参数:
InvocationHandler接口中有一个办法invoke;
public Object invoke(Object proxy, Method method, Object[] args);
参数 proxy 就是 代理对象
参数 method 就是 调用办法
参数 args 就是调用的 办法的参数
返回值, 就是实在行为执行后返回的后果，会传递给代理对象调用的办法.
eg：

public class Student implements Person {

public String say(String message) {

return “hello ” + message;

}

}

public class StudentProxyTest {

public static void main(String[] args) {

// 做 Person 接口实现类 Student 的动静代理。

// 1. 创立一个 Student 被代理

final Person s = new Student();

// 2. 失去 s 的代理对象.

Person sproxy = (Person) Proxy.newProxyInstance(s.getClass()

.getClassLoader(), s.getClass().getInterfaces(),

new InvocationHandler() {

// 参数 proxy 就是代理对象

// 参数 method 就是调用办法

// 参数 args 就是调用的办法的参数

// 返回值, 就是实在行为执行后返回的后果，会传递给代理对象调用的办法.

public Object invoke(Object proxy, Method method,

Object[] args) throws Throwable {

// proxy, 就是代理对象，咱们个别不应用。

// method, 就是要拜访的办法。

// args 就是要拜访的办法的参数

return method.invoke(s, args); // s.say(“james”);

}

});

String message = sproxy.say(“james”); // 这个是代理对象调用 say 办法.

System.out.println(message);

}

}

public class LoginServlet extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

String username = request.getParameter(“username”);

System.out.println(username);

}

public void doPost(HttpServletRequest request, HttpServletResponse response)

throws ServletException, IOException {

doGet(request, response);

}

}

2. 操作

public class EncodingFilter implements Filter {

public void init(FilterConfig filterConfig) throws ServletException {

}

public void doFilter(ServletRequest request, ServletResponse response,

FilterChain chain) throws IOException, ServletException {

// 1. 强转

final HttpServletRequest req = (HttpServletRequest) request;

HttpServletResponse resp = (HttpServletResponse) response;

// 2. 操作

// 创立一个 req 对象的代理对象 reqProxy

HttpServletRequest reqProxy = (HttpServletRequest) Proxy

.newProxyInstance(req.getClass().getClassLoader(), req

.getClass().getInterfaces(), new InvocationHandler() {

public Object invoke(Object proxy, Method method,

Object[] args) throws Throwable {

// 1. 失去办法名称

String methodName = method.getName();

if (“getParameter”.equals(methodName)) {

String param = req.getParameter((String) (args[0]));

return new String(param.getBytes(“iso8859-1”),

“utf-8”);

} else {

// 不是 getParameter 办法，就执行其原来操作.

return method.invoke(req, args);

}

}

});

// 3. 放行

chain.doFilter(reqProxy, resp);

}

public void destroy() {

}

}

数据库

create table users(

id int primary key auto_increment,

username varchar(40),

password varchar(40)

);

insert into users values(null,’aaa’,’111′);

insert into users values(null,’bbb’,’111′);

insert into users values(null,’ccc’,’111′);

create table privileges(

id int primary key auto_increment,

name varchar(40)

);

insert into privileges values(null,’ 增加图书 ’);

insert into privileges values(null,’ 批改图书 ’);

insert into privileges values(null,’ 查看图书 ’);

insert into privileges values(null,’ 删除图书 ’);

多对多表关系

create table userprivilege(

user_id int ,

privilege_id int,

foreign key(user_id) references users(id),

foreign key(privilege_id) references privileges(id),

primary key(user_id,privilege_id)

);

insert into userprivilege values(1,1);

代码实现:
1. 实现登录操作，将 user 存储到 session 中.
login.jsp LoginServlet UserService UserDao.
2. 登录胜利，跳转到 book.jsp 页面。
能够通过在申请，携带参数来判断要做什么操作
在这个页面上有四个超连贯，拜访的是同一个 servlet（BookServlet）
问题: 怎么让一个 servlet 解决多个申请？

book add

book update

book delete

book search

在 servlet 中判断 method 值是什么，调用不同的申请解决办法.
这种形式下，在做权限管制时，如果应用 url 级别权限管制，就不能通过判断申请的资源门路来解决。
能够应用细粒度权限管制:
实现原理: 应用注解 + 动静代理来实现。
注解: 它用于定义以后行为的拜访须要什么权限。
动静代理帮忙咱们实现管制拦挡。简略说，就是在代理中，会判断以后用户是否具备拜访该行为的权限, 如果有会调用被代理的行为，如果没有，不调用行为，间接抛出权限有余。
3. 实现权限管制
1. 创立一个 BookInfo 注解，它是用于形容行为拜访时，须要什么权限的.

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

@Inherited

public @interface BookInfo {

String value(); // 这就是权限名称

}

2. 在 BookServiceFactory 中进行权限管制

1. 失去以后行为拜访须要的权限名称
BookInfo bif = method.getAnnotation(BookInfo.class);
String pname = bif.value();
2. 失去以后登录的用户
User user = (User) args[0];
咱们在所有的 service 的办法上增加了一个 User 参数。
那么咱们获取时，就能够间接通过 invoke 办法的 args 参数获取.
1. 首先判断用户是否存在，也就是判断它是否登录了。

User user = (User) args[0];

if (user == null) {

throw new RuntimeException(“ 没有登录，请登录后操作 ”);

}

2. 如果登录了，依据用户查询数据库，失去这个用户所具备的所有权限名称

* 应用 ColumnListHandler 进行封装查问后果。

SELECT

privileges.name

FROM

users,PRIVILEGES,userprivilege

WHERE

users.id=userprivilege.user_id

AND

privileges.id=userprivilege.privilege_id

AND

users.id=?”;

QueryRunner runner = new QueryRunner(DataSourceUtils

.getDataSource());

List<Object> pnames = runner.query(sql,

new ColumnListHandler(), user.getId());

判断用户是否具备权限

// 实在行为拜访前 – 判断用户是否有权限执行以后行为

boolean flag = method.isAnnotationPresent(BookInfo.class);

if (!flag) {

// 不须要权限

return method.invoke(service, args);

}

if (pnames.contains(pname)) {

Object obj = method.invoke(service, args);

// 实在行为拜访后

return obj;

} else {

throw new RuntimeException(“ 权限有余 ”);

什么是类加载器，有什么作用?
1. 疏导类加载器 BootStrap jre/lib/rt.jar
2. 扩大类加载器 ExtClassLoader JRE/lib/ext/*.jar
3. 利用类加载器(零碎类加载器) AppClassLoader SystemClassLoader CLASSPATH 指定的所有 jar 或目录
类加载器的作用就是将 java 中的字节码文件 (.class 文件) 转换成 Class 对象。
当 JVM 启动时，会造成由三个类加载器组成的初始类加载器层次结构：
在 java 中 ClassLoader 代表类加载器，所有的类加载器都是 ClassLoader 的子.
bootstrap classloader：疏导（也称为原始）类加载器，它负责加载 Java 的外围类。这个加载器的是十分非凡的，它实际上不是 java.lang.ClassLoader 的子类，而是由 JVM 本身实现的。能够通过执行以下代码来取得 bootstrap classloader 加载了那些外围类库：

URL[] urls=sun.misc.Launcher.getBootstrapClassPath().getURLs();

for (int i = 0; i < urls.length; i++) {

System.out.println(urls[i].toExternalForm());

}

因为 JVM 在启动的时候就主动加载它们, 所以不须要在零碎属性 CLASSPATH 中指定这些类库
演示类加载器
在 Class 类中有一个办法 getClassLoader()它返回的就是一个类加载器.
问题: 类加载器如果获取?
1. 获取疏导类加载器
ClassLoader cl = String.class.getClassLoader();
System.out.println(cl);
后果是 null.
起因: 疏导类加载器非凡，它基本就不是 java 实现。所有在失去疏导类回载器是后果就是 null.
2. 扩大类加载器
ClassLoader cl = AccessBridge.class.getClassLoader();
System.out.println(cl); //sun.misc.Launcher$ExtClassLoader@9cb0f4
3. 利用类加载器
ClassLoader cl = this.getClass().getClassLoader();
System.out.println(cl); //sun.misc.Launcher$AppClassLoader@164dbd5

全盘负责：即是当一个 classloader 加载一个 Class 的时候，这个 Class 所依赖的和援用的其它 Class 通常也由这个 classloader 负责载入。
委托机制：先让 parent（父）类加载器寻找，只有在 parent 找不到的时候才从本人的类门路中去寻找。
类加载还采纳了 cache 机制：如果 cache 中保留了这个 Class 就间接返回它，如果没有才从文件中读取和转换成 Class，并存入 cache，这就是为什么批改了 Class 然而必须重新启动 JVM 能力失效, 并且类只加载一次的起因。

创立了一个类 javax.activation.MimeType，在这个类中有一个办法 show(); 当 jvm 加载这个类时，因为在 rt.jar 包下也存在一个 MimeType 类，并且包名都一样，这时 jvm 就会应用疏导类加载器加载这个类，而咱们想得到的其实是应该由利用类加载器加载的 Class.
解决方案: 自定义类加载器.
1. 创立一个类，去继承自 ClassLoader
2. 重写 findClass 办法，在这个办法中通过 defineClass 将一个.class 文件转换成 Class 对象.

问题: 在 BaseDaoImpl 类中须要失去以后这个类上的泛型的 Class 对象，而间接通过 T.class 这是不对的.
怎么失去以后这个类上的泛型的 Class?
Type type = this.getClass().getGenericSuperclass(); // 失去以后类上的泛型–父类型
Type[] params = ((ParameterizedType) type).getActualTypeArguments(); // 失去以后类上所有的泛型类型 Class
clazz = (Class) params[0]; 中须要失去以后这个类上的泛型的 Class 对象，而间接通过 T.class 这是不对的.
怎么失去以后这个类上的泛型的 Class?
Type type = this.getClass().getGenericSuperclass(); // 失去以后类上的泛型–父类型
Type[] params = ((ParameterizedType) type).getActualTypeArguments(); // 失去以后类上所有的泛型类型 Class
clazz = (Class) params[0];
问题: 在 BaseDaoImpl 类中须要失去以后这个类上的泛型的 Class 对象，而间接通过 T.class 这是不对的.
怎么失去以后这个类上的泛型的 Class?
Type type = this.getClass().getGenericSuperclass(); // 失去以后类上的泛型–父类型
Type[] params = ((ParameterizedType) type).getActualTypeArguments(); // 失去以后类上所有的泛型类型 Class
clazz = (Class) params[0];

正文完

java

发表至： java

2020-11-18

0

工具集核心教程 | 第一篇： .md即markdown文件的基本常用编写语法（图文并茂）

关于java:一款简易的Java工作流框架

关于java:万字长文深入剖析volatileJava

关于java:谈谈JVM内部锁升级过程

关于程序员:在libp2prs上开发新协议

关于java:我在上海乐字节学习的第二十四天持续更新中

动静代理

代理模式

AOP：面向切面的编程

动静代理实现

动静代理案例 1—实现编码过滤

动静代理案例 2–细粒度的权限管制

类加载器

全盘负责委托机制

自定义类加载器

==== 动静代理

代理模式

AOP：面向切面的编程

动静代理实现

动静代理案例 1—实现编码过滤

动静代理案例 2–细粒度的权限管制

类加载器

全盘负责委托机制

自定义类加载器

泛型反射

代理模式

AOP：面向切面的编程

动静代理实现

动静代理案例 1—实现编码过滤

动静代理案例 2–细粒度的权限管制

类加载器

全盘负责委托机制

自定义类加载器

泛型反射

站内搜索