Puntos clave de esta sección:
Java proxy estático
Agente dinámico JDK
1 problemas encontrados en ideas de diseño orientadas a objetos
En la programación OOP tradicional, los objetos son centrales y se forma una función de software completa a través de la colaboración entre objetos. Dado que los objetos pueden ser heredados, podemos abstragar atributos con las mismas funciones o las mismas características en un sistema de estructura de clase claramente jerárquico. Con la expansión continua de las especificaciones de software, la división más profesional del trabajo se está volviendo cada vez más series, y el creciente número de prácticas de aplicación OOP también ha expuesto algunos problemas que OOP no puede resolver bien.
Ahora suponga que hay tres piezas de código completamente similares en el sistema, que generalmente se completan al "copiar" y "pegar". El software desarrollado de esta manera se muestra en la figura:
Los lectores pueden haber descubierto las deficiencias de este enfoque. Si un día el código con fondo azul necesita ser modificado, ¿deberíamos modificar tres lugares al mismo tiempo? Si no solo estos tres lugares contienen este código, sino 100, o incluso 1,000 lugares, ¿cuáles serán las consecuencias?
El registro está en todas partes en el código: primero busque un ejemplo:
Para rastrear el funcionamiento de una aplicación, muchos métodos requieren información de registro. Normalmente escribimos esto:
// Consulte el artículo "Log4j Introducción" para log4j importar org.apache.log4j.logger; public class Person {private logger logger = logger.getLogger (persona.class); public void sleep () {logger.info ("Inicie la hora de ejecución:" + nueva fecha ()); System.Println ("Sleepe"); Logger.info ("" Tiempo de ejecución: "" Fecha (")); Date ());} public void eating () {logger.info ("Inicie la hora de ejecución:" + nueva fecha ()); Date () "); system.out.println (" incubación "); logger.info (" "Tiempo de finalización de ejecución:" + nueva fecha () ");}}Pregunta: ¿Cuáles son las desventajas?
l confunde las responsabilidades del método comercial en sí
La carga de trabajo de mantenimiento es enorme
2 Solución 1
Proxy estático:
1. Necesita saber qué clase es la clase central (clase proxy) y qué métodos hay.
2. El código no es necesario repetirse varias veces, lo que hace que la estructura del código parezca hincharse y crea redundancia de código.
3. Las clases no básicas (clases proxy) deben implementar interfaces implementadas por clases básicas (clases proxy), es decir, deben implementar interfaces comunes, pero prevalecerán las interfaces implementadas por clases básicas (clases proxy).
El propósito de L es separar completamente el código de negocio del código de registro y lograr un acoplamiento suelto.
El objeto proxy y el objeto proxy deben implementar la misma interfaz, implementar servicios relacionados para iniciar sesión en el objeto proxy y llamar al objeto proxy cuando sea necesario, mientras que el objeto proxy solo conserva el código de negocio.
Implementación de proxy estático
1) Defina la interfaz:
interfaz pública iperson {public abstract void sleep (); public abstract void eating ();}2) Clase proxy
La persona de clase pública implementa iperson {public void sleep () {System.out.println ("durmiendo");} public void eating () {System.out.println ("comer");}}3) Clase de agente
importar org.apache.log4j.logger; public class Personproxy implementa iperson {private iperson persona; private logger = logger.getlogger (personaproxy.class); public personproxy (persona iperson) {this.person = persona;} public void eating () {logger.info ("Iniciar tiempo de ejecución:" + nuevo Date () "); persona.eating (); logger.info (" "Tiempo de finalización de ejecución:" + new date () ");} public void sleep () {logger.info (" Inicie la hora de ejecución: " + new Date ()"); Person.sleep (); logger.info ("" Tiempo de fin de ejecución: " + New Date ()");}}}}}}4) Clase de prueba
paquete com.aptech.aop2; public class Persontest {public static void main (string [] args) {iperson proxy = new Personproxy (new Person ()); proxy.eating (); proxy.sleep ();}}Desventajas del proxy estático:
Una interfaz proxy solo puede servir a un tipo de objeto. Es simplemente incompetente para proyectos ligeramente más grandes.
3 Solución Agente 2-dinámico
InvocationHandler: cada clase de proxy dinámica debe implementar la interfaz InvocationHandler, y cada instancia de la clase proxy está asociada con un controlador. Cuando llamamos a un método a través del objeto proxy, la llamada de este método se reenviará al método Invoke de la interfaz InvocationHandler para llamar.
Después de JDK1.3, se agregó una función de proxy dinámica que puede ayudar en el desarrollo. No es necesario escribir objetos proxy específicos para objetos y métodos específicos. El uso de proxy dinámico puede hacer que un controlador sirva a cada objeto.
El diseño de clase de un procesador debe implementar la interfaz java.lang.reflect.invocationHandler.
El proxy dinámico implementado a través de la interfaz InvocationHandler solo puede representar la clase de implementación de la interfaz.
Implementación de proxy dinámico
1) manejador
public class DynaproxyHandler implementa InvocationHandler {private logger logger = logger.getLogger (dynaproxyHandler.class); private object Target; // proxy Object Void Void setTarget (Object Target) {this.target = Target;} public Object Invoke (Object Proxy, método, método, Object [] args) lanza {Logger.info ("" "" Ej. Date ()); objeto resultado = método.invoke (target, args); logger.info ("Tiempo de finalización de ejecución:" + nueva fecha ()); resultado de retorno; // Resultado de ejecución del método de retorno}}2) Fábrica para agente de producción
import java.lang.reflect.proxy; public class dynaproxyFactory {// obj es el objeto proxy público objeto estático getProxy (object obj) {dynaproxyHandler Handler = new DynapRoXyHandler (); Handler.setTarget (obj); return proxy.newproxyinstance (Obj.getClass (). obj.getClass (). GetInterfaces (), Handler);}}3) Clase de prueba
Public Class Persontest {public static void main (String [] args) {iperson persona = (iperson) dynaproxyFactory.getProxy (nueva persona ()); // Devuelve la clase proxy, la clase proxy es creada dinámicamente por el JVM en la memoria. Esta clase implementa todas las interfaces (todos los métodos) de la interfaz entrante array.person.eating (); persona.sleep ();}}Resumir
Lo anterior es toda la explicación detallada del proxy static spring y el código de proxy dinámico en este artículo. Espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a este sitio:
Configuración y análisis Común Descripción de la clase de Spring
SpringMVC Interceptor implementa el inicio de sesión único
Implementación de programación de Java del ejemplo de inicio de sesión simple de SpringMVC
Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!