Métodos para implementar la construcción de proyectos distribuidos en Java

1 distribuido

1.1 Lo que se distribuye

1. Un sistema distribuido debe ser un sistema compuesto por múltiples nodos. Entre ellos, los nodos se refieren a servidores de computadora, y estos nodos generalmente no están aislados sino interoperables.
2. Nuestros nodos se implementan en estos nodos conectados, y sus operaciones serán coordinadas. Para los usuarios, se enfrentan a un servidor que proporciona los servicios que necesitan. De hecho, estos servicios son un sistema distribuido compuesto por muchos servidores detrás de ellos, por lo que el sistema distribuido parece una supercomputadora.

1.2 La diferencia entre distribuidos y clústeres

1. El clúster es la misma unidad del sistema en diferentes servidores, por ejemplo, una unidad del sistema de inicio de sesión en diferentes servidores.
2. El sistema distribuido significa que diferentes departamentos del sistema se llaman entre sí en diferentes servidores.

Resulta que solo hay un chef en el pequeño restaurante, que corta vegetales, lava vegetales, prepara ingredientes y los agita a todos. Más tarde, había más clientes, y un chef en la cocina estaba demasiado ocupado, por lo que contrató a otro chef. Ambos chefs podrían cocinar los mismos platos. La relación entre estos dos chefs fue un clúster. Para dejar que el chef se concentre en cocinar y hacer lo mejor de los platos, contrató un guarnición para ser responsable de cortar verduras, preparar platos y preparar ingredientes. La relación entre el chef y la guarnición se distribuye, y un guarnición está demasiado ocupado, por lo que contrató un guarnición, y la relación entre el plato de dos es un clúster.

2. Construya un proyecto distribuido

Herramientas de preparación: Eclipse, VMWarm equipado con sistema CentOS7, Zookeeper ... lo más importante es una máquina de ancianos de tres años.

1 Primero cree un proyecto maven de la clase principal, y el método de empaque es POM.

Cree un proyecto Maven de clase principal en Eclipse, y el método de embalaje es POM. ¿Por qué crear un proyecto Maven de clase matriz? Debido a que desea utilizar este proyecto Maven para administrar varias versiones de paquetes JAR, si la subclase quiere el paquete JAR directamente y la clase principal, puede hacerlo. xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd "> <modelVersion> 4.0.0 </modelversion> <MoupRupid> com.itqf </groupid> <artifactid> sing-parent </artifactid> <version> Paquetes-> <Propiedades> <Junit.version> 4.12 </junit.version> <spring.version> 4.2.4.release </spring.version> <mybatis.version> 3.2.8 </mybatis.version> <mybatis.spring.version> 1.2.2 <2 < /mybatis.spring.version><mybatis.paginator.version>1.2.15</mybatis.paginator.version><mysql.version>5.1.32</mysql.version><SLF4J.Version>1.6.4</slf4j.Ve rsion> <jackson.version> 2.4.2 </jackson.version> <druid.version> 1.0.9 </druid.version> <httpclient.version> 4.3.5 </httpclient.version> <jstl.version> 1.2 </jstl .versión> <Servlet-api.version> 2.5 </servlet-api.version> <jsp-api.version> 2.0 </jsp-api.version> <joda times.version> 2.5 </joda-imitat.version> <Commons-lang3.ve rsion> 3.3.2 </commons-lang3.version> <commons-io.version> 1.3.2 </commons-io.version> <commons-net.version> 3.3 </commons-net.version> <pagehelper.version> 3.4. 2-fix </pagehelper.version> <jsqlparser.version> 0.9.1 </jsqlparser.version> <commons-fileupload.version> 1.3.1 </commons-fileupload.version> <jedis.version> 2.7 .2 </jedis.version> <solrj.version> 4.10.3 </solrj.version> <dubbo.version> 2.5.3 </dubbo.version> <Zookeepers.version> 3.4.7 </zookeeeper.version> <zkclient.versio n> 0.1 </zkclient.version> <activemq.version> 5.11.2 </activemq.version> <freemarker.version> 2.3.23 </freemarker.version> <cuartz.version> 2.2.2 </quartz.version> </propiedades> <!-Administre los paquetes JAR utilizados en todos los proyectos, sin dependencias reales-> <dependencyManagement> <Spendencies> <!-Componente de operación de tiempo-> <pendency> <MoupRupid> Joda-Time </GroupId>

2 Crear un proyecto de agregación Maven.

2.1 Crear un proyecto de agregación Maven y heredar el proyecto principal.

Ingeniería de agregación: la capa del controlador, la capa de vista, etc. en el proyecto se puede formar independientemente en un proyecto y finalmente integrarse en un proyecto cuando finalmente se ejecuta.

pom.xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.itqf</groupId> <artifactId>sing-parent</artifactId> <version>0.0.1-SNAPSHOT</version> </parent> <groupId>com.itqf</groupId> <artifactid> sing-manager </arfactid> <versión> 0.0.1-snapshot </versewer> <cackaging> pom </packaging> <pendencies> <sependency> <grupoD> com.itqf </proupid> <artifactid> sing-common </artifactid> <version> 0.0.1-snapshot </lipsion> </dependencias> <DIARD> <GULTINS> <LEMPLEMIN> <MOURGEID> org.apache.tomcat.maven </proupid> <artifactid> tomcat7-maven-plugin </arfactid> <figuration> <port> 8083 </port> <path>/</phation> </figuration> </glugin> </glugins> </stract> <modules> <Modules> Sing-Manager-Pojo </module> <smodule> Sing-Manager-Interface </smodule> <smodule> Sing-Manager-Service </module> <smodule> Sing-Manager-Mapper </module> </modules> </jection>

2.2 Cree un módulo Maven en el proyecto de agregación y nombrelo Sping-Manager-Pojo (capa de clase de entidad).

POJO es un formato de jares normal y no necesita confiar en el proyecto principal.

pom.xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd "> <modelVersion> 4.0.0 </modelversion> <Parent> <MoupRid> com.itqf </groupid> <artifactid> sing-ganager </artifactid> <versión> 0.0.1-snapshot </sions> </parent> <ArFactId> Sing-Manager-Pojo </artifactid> </jection>

2.3 Cree un módulo Maven en el proyecto de agregación y nombre al Spring-Manager-Mapper (capa DAO). Confíe en POJO en el archivo pom.xml. Debido a que el método de la capa mapeador devuelve un objeto de clase de entidad, POJO debe usarse.

Paquetes JAR de dependencia de importación.

xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd "> <modelVersion> 4.0.0 </modelversion> <Parent> <MoupRid> com.itqf </groupid> <artifactid> sing-ganager </artifactid> <versión> 0.0.1-snapshot </sions> </parent> <Atifactid> Sing-Manager-Mapper </artifactid> <!-Dependency Pojo-> <pendencies> <Spendency> <MoupRoD> com.itqf </groupid> <artifactid> sing-manager-pojo </arfactid> <versión> 0.0.1-snapshot </sions> </dependency> <!-mybatis -> <Spendency> <MoupRoD> org.mybatis </groupid> <artifactid> mybatis </arfactid> <version> $ {myBatis.version} </verversion> </pendency> <pendency> < Groupid> org.mybatis </proupid> <artifactid> mybatis-spring </artifactid> <versever> $ {mybatis.spring.version} </verversion> </dependence> <pendency> <gro upid> com.github.miemiedev </groupid> <artifactid> mybatis-paginator </artifactid> <versión> $ {mybatis.paginator.version} </versión> </pendency> <de Pendency> <MoupRid> com.github.pagehelper </groupid> <artifactid> pageHelper </artifactid> <versión> $ {pageHelper.version} </verversion> </pendency> <!- Mysql-> <pendency> <MoupRId> mysql </groupid> <artifactid> mysql-connector-java </artifactid> <versión> $ {mysql.version} </verse> </pendency> <!-conexión Pool-> <Spendency> <MoupRid> com.alibaba </groupid> <artifactid> druid </artifactid> <versever> $ {druid.version} </versión> </pendency> </pendencs> </jecter>

2.4 Cree una interfaz de manager de primavera (interfaz) en el proyecto de agregación y coloque todas las interfaces de servicio en un proyecto independiente. Si el valor de retorno del método en la interfaz es una clase de entidad, se requiere POJO. Por lo tanto, depende de POJO xml en POM.

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd "> <modelVersion> 4.0.0 </modelversion> <Parent> <MoupRid> com.itqf </groupid> <artifactid> sing-ganager </artifactid> <versión> 0.0.1-snapshot </sions> </parent> <artifactid> sing-manager-interface </arfactid> <pendencies> <pendency> <grupid> com.itqf </groupid> <artifactid> sing-manager-pojo </arfactid> <version> 0.0.1-snapshot </pions> </pendency> </pendences> </jection>

2.5 Cree Spring-Manager-Service (clase de implementación de interfaz) en el proyecto de agregación. El método de empaque es la guerra

Debido a que la capa del controlador se separa de la capa de servicio, al ejecutar y comenzar, el controlador y el servicio deben publicarse por separado utilizando TomCat, y todos los archivos de configuración requeridos en el proyecto de agregación se colocan en el servicio, de modo que todos los archivos de configuración se cargarán e integrarán cuando se inicia TomCat.

1. El servicio debe usar una interfaz, por lo que depende de la interfaz de interfaz-interfaz de gerente.
2. El servicio debe usar POJO y también debe llamar a Mapper, por lo que puede confiar directamente en Mapper, pensando que Mapper ya se ha basado en POJO (entrega de dependencia) .
3. El servicio debe ser administrado por Spring, deje que Spring cree objetos para el servicio
4. El servicio requiere el paquete Dubbo (introducido más adelante en Dubbo)
5. El servicio debe usar SOA y publicar el servicio como un servicio.

Archivo de configuración

SqlMapConfig.xml

 <? xml versión = "1.0" encoding = "utf-8"?> <! DocType ConfigurationPublic "-// mybatis.org//dtd config 3.0 // en" "http://mybatis.org/dtd/mybatis-3-config.dtdd"> <Conacuration> </figuration>

db.properties

 db.driver = com.mysql.jdbc.driverdb.url = jdbc: mysql: // localhost: 3306/taotao? caracterSencoding = utf-8db.username = rootdb.password = root

applicationContext-tx.xml

 <? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/s Chema/context "xmlns: mvc =" http://www.springframework.org/schema/mvc "xmlns: tx =" http: //www.springfr amework.org/schema/tx"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:dubbo="http://c ode.alibabatech.com/schema/dubbo"xsi:schemalocation="http://www.springframework.org/schema/beanss http://www.springframework.org/schema/Beans/spring-Beans-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.4.2. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springfframework.orgsschema/aop/ http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://code.alibabatech.com/schema/dubbo http://code.alibatech.com/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.2.xsd "> <bean id =" txmanager "> <sperty name =" dataSource "ref =" datasource " id = "Asegioid" Transaction-Manager = "TxManager"> <tx: atributes> <tx: método name = "add*" propagation = "requerido"/> <tx: método name = "salvar*" propagation = "requerido"/> <tx: método name = "insert*" propagation = "requerido"/> <tx: name de método = "inserto*" propagation = = "requerido"/"requerido"/"requerido" requerido "requerido" requerido "requerido" requerido "requerido" requerido "requerido" " propagation = "requerido"/> <tx: método name = "del*" propagation = "requerido"/> <tx: método name = "find*" propagation = "admite" read-ingly = "true"/> <tx: name = "get*" propagation = "admite" ready = "true"/> </tx: atributes> </tx: consejo> <aop: config: Configure consejo-ref = "Asegioid" PointCut = "Ejecution (*com.itqf.service ..*.*(..))"/> </aop: config> </beans>

applicationContext-dao.xml

 <? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/context" xmlns: mvc = "http: //www.springfr amework.org/schema/mvc"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xsi:schemalocation="http://www.springframework.org/schema/beanss http://www.springframework.org/schema/Beans/spring-Beans-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.4.2. http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd "> <context: Property-placeholeation =" classpath: resource/*. Propiedades "/> <bean id =" dataSource "> <name de propiedad =" valor de controlador "valor =" $ {db.driver} "> </" dataSource "> <name de propiedad =" valor "virtual" valor = "$ {db.driver}"> </"dataSource"> <name de propiedad = "valor" virtual "valor =" $ {db.driver} "> </" dataSource "> <name de propiedad =" valor de "classname" valor = "$ {db.driver}" </apropiada </"name de propiedad de propiedad =" name = "name =" Url "". value = "$ {db.url}"> </propiety> <Property name = "username" value = "$ {db.username}"> </property> <propiedad name = "contraseña" value = "$ {db.password}"> </sperties> <propiedad name = "maxactive" value = "10"> </propiedad de propiedad = "name =" minidle "value" value "5" 5 "5" 5 " <Bean> <Property Name = "DataSource" ref = "DataSource"> </property> <Property name = "configLocation" value = "classpath: mybatis/sqlmapconfig.xml"> </property> </bean> <bean> <bean name = "baseepackage" value = "com.itqf.mapper"> </property> </bean> </beans>

applicationContext-service.xml

 <? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/context" xmlns: mvc = "http: //www.springfr amework.org/schema/mvc"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xsi:schemalocation="http://www.springframework.org/schema/beanss http://www.springframework.org/schema/Beans/spring-Beans-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.4.2. http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd "> <context: component-scan base-package =" com.itqf.service "> </context: component-scan> </beachs>

pom.xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd "> <modelVersion> 4.0.0 </modelversion> <Parent> <MoupRid> com.qianfeng </proupid> <artifactid> sing-manager </artifactid> <PROPESSONS> 0.0.1-SNAPSHOT </Version> </parent> <artifactid> sing-manager-service </artifactid> <packaging> war </packaging> <pendencies> <pendency> <uproupid> com.qianfeng </groupid> <artifactid> sing-manager-interface </arfactid> <versión> 0.0.1-snapshot </versión> </pendency> <pendency> <proupid> par.qenfeng </groupheng> <artifactid> sing-manager-mapper </artifactid> <versión> 0.0.1-snapshot </lipeers> </pendency> <!-Primavera -> <Spendency> <MoupRoid> org.springframework </groupid> <artifactid> spring-Context </arfactiDID> <versever> $ {spring.version} </versión> </dependency> <epardency> <grupid> org.springframework </proupid> <artactid> spring-beans </artifactid> <lection> $ {{{{{» ring.version} </versión> </pendency> <epardency> <grupid> org.springframework </groupid> <artifactid> spring-webmvc </artifactid> <versión> $ {spring.version} </versión> </dependence> <epardency> <proupid> org.springframework </proupid> <artifactid> spring- spring- spring- spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- spring- Spring- Spring- jdbc </arifactid> <versers> $ {spring.version} </versión> </pendency> <Spendency> <uproupid> org.springframework </groupid> <artifactid> spring-aspects </arfactiCid> <Version> $ {spring.version} </verse> </dependency> <pendency> rk </proupid> <artifactid> spring-jms </artifactid> <versever> $ {spring.version} </versión> </pendency> <peperse> <MoupRupid> org.springframework </proupId> <artifactID> spring-context-support </artifactid> <proion> $ {spring.version} </versión> </Versión> </Versión> </shifactID> Spring-Context-Support </artifactId> <Version> $ {Spring.Version} </Versión> </Versión> </Versión> </Versión>

Estructura de ingeniería final

3 Use Dubbo para publicar el servicio

¿Piensas primero?

Los sitios web de centros comerciales como Taobao y JD no solo pueden iniciar sesión desde el lado de la PC, sino también desde el lado del teléfono móvil. ¿Cómo se implementa? Escribir dos controladores? Eso definitivamente no lo es. ¿Quién no tendrá nada que hacer cuando no tengas nada que hacer? Entonces esto requiere el uso de SOA (arquitectura orientada al servicio). Cuando escribamos un proyecto usando distribuido, habrá muchos sistemas para llamarse entre sí. Si llama de ida y vuelta, la estructura del código será muy confusa. Aquí usamos Dubbo para manejar el problema de demasiados servicios de publicación y no tener claro al respecto.

Que es SOA

SOA es un método de diseño que incluye múltiples servicios, y los servicios eventualmente proporcionarán una serie de funciones a través de la cooperación. Por lo general, existe un servicio en forma independiente en un proceso de sistema operativo. Los servicios se comunican a través de la red, en lugar de llamadas en el proceso.

Por ejemplo, ahora tiene muchos servicios: servicios de noticias (que brindan liberación de prensa, visualización, modificación, deleción), servicios de pedidos (adición de pedidos, modificación de pedidos, visualización de pedidos, deleción de pedidos, etc.) Servicios financieros (ingresos, gastos, estadísticas, etc.) Servicios de empleados (nuevo, modificación, visualización, estadísticas) Servicios de asistencia (Servicios de firma, firma, devolución, estadísticas, estadísticas, etc.) Servicios de ventas (Venta de ventas, estadísticas de ventas, estadísticas de ventas, estadísticas).)

dubbo

¿Qué es DUBBO (una herramienta de gestión para la programación de recursos y el Centro de Gobierno)?

Con el desarrollo de Internet, la escala de las aplicaciones del sitio web se ha ampliado continuamente, y las arquitecturas de aplicaciones verticales convencionales ya no pueden hacer frente a ella. Las arquitecturas de servicios distribuidos y las arquitecturas de computación móvil son imperativas. Se necesita urgentemente un sistema de gobierno para garantizar la evolución ordenada de la arquitectura.

Arquitectura de aplicación única

1. Cuando el tráfico del sitio web es pequeño, solo se necesita una aplicación para implementar todas las funciones juntas para reducir los nodos y costos de implementación.
2. En este momento, el Marco de acceso de datos (ORM) utilizado para simplificar la carga de trabajo de agregar, eliminar, modificar y verificar es la clave.

Arquitectura de aplicaciones verticales

1. A medida que aumenta el número de visitas gradualmente, la aceleración traída por una sola aplicación para aumentar la máquina se vuelve cada vez más pequeña, y la aplicación se divide en varias aplicaciones que son irrelevantes para mejorar la eficiencia.
2. En este punto, el marco web (MVC) utilizado para acelerar el desarrollo de la página frontal es clave.

Arquitectura de servicio distribuido

1. Como hay más y más aplicaciones verticales, las interacciones entre las aplicaciones son inevitables. Los servicios centrales se extraen como servicios independientes, y se forma gradualmente un centro de servicio estable, para que las aplicaciones frontales puedan responder a las demandas cambiantes del mercado más rápidamente.
2. En este momento, el Marco de Servicio Distribuido (RPC) utilizado para mejorar la reutilización e integración del servicio es la clave.

Arquitectura de la computación de flujo

1. A medida que hay más y más servicios disponibles, los problemas como la evaluación de la capacidad y el desperdicio de pequeños recursos de servicio están surgiendo gradualmente, se debe agregar un centro de envío para administrar la capacidad del clúster en tiempo real en función de la presión de acceso para mejorar la utilización del clúster.
2. En este punto, el Centro de programación y gobernanza de recursos (SOA) para mejorar la utilización de la máquina es clave.

Construcción del entorno Dubbo:

Descripción del rol del nodo:

1. Proveedor: el proveedor de servicios que expone el servicio.
2. Consumidor: el consumidor de servicio que llama al servicio remoto.
3. Registro: Centro de registro para el registro y descubrimiento de servicios.
4. Monitor: Centro de monitoreo que cuenta el número de llamadas y el tiempo de llamadas del servicio.
5. Contenedor: el servicio ejecuta el contenedor.

Descripción de la relación de llamada:

1. El contenedor de servicio es responsable de comenzar, cargar y ejecutar el proveedor de servicios.
2. Cuando comienza el proveedor de servicios, registra los servicios que brinda con el centro de registro.
3. Cuando comiencen los consumidores de servicios, suscríbase a los servicios que necesitan para el registro.
4. El centro de registro devuelve la lista de direcciones de proveedores de servicios al consumidor. Si hay algún cambio, el centro de registro impulsará los datos de cambio al consumidor en función de la larga conexión.
5. Para atender a los consumidores, según el algoritmo de equilibrio de carga suave, seleccione un proveedor para llamarlo. Si la llamada falla, seleccione otra llamada. Servicios de los consumidores y proveedores, acumulan el número de llamadas y el tiempo de llamadas en la memoria, y envíe estadísticas al centro de monitoreo regularmente cada minuto.

Aquí llegamos principalmente al Centro de Registro (Registro), y usamos Zookeeper para actuar como el Centro de Registro.

Implementar el registro en el entorno de Linux, Zookeeper

Por supuesto, el primer paso es encender la máquina virtual, por lo que lo haré en CentOS7.

Obtenga un paquete comprimido en Zookeeper en línea, el mío es Zookeeper-3.4.6.tar.gz

Peque el directorio en /opt y descomprima. (Se requiere el entorno JDK. Si no hay un entorno JDK, instale primero un JDK)

Ingrese el directorio Zookeeper-3.4.6 y cree una carpeta llamada datos.

Renombrar zoo_sample.cfg en el directorio ./conf a zoo.cfg modifique el atributo de datos en zoo.cfg: dataDir =/opt/zookeeper-3.4.6/data

Paso 7:

1. Empiece a Zookeeper.
2. Inicio: ./ zkserver.sh inicio
3. Cerrar: ./ zkserver.sh parada
4. Estado de vista: ./ Zkserver.sh Status

¡Tenga en cuenta que después de que se inicia Zookeeper, debe apagar el firewall! Eso es todo.

Agregar archivo de configuración al servicio ApplicationContext-Service.xml para publicar el servicio

 < > </dubbo: registro> <!-Expone el servicio a un número de puerto de puerto de puerto, seleccione un puerto que no esté ocupado-> <dubbo: Protocol name = "dubbo" puerto = "20888"> </dubbo: protocol> <!-Exponga el servicio de puerto de puerto cierto, seleccione un puerto que no está ocupado-> <dubbo: Protocol name = "Dubbo" Dubbo " Port = "20888"> </Dubbo: Protocol> <!-Ref es el nombre del objeto de servicio creado por el contenedor Spring-> <Dubbo: Service Interface = "com.itqf.service.itemservice" ref = "itemserviceImpl" timeOut = "6000000"> </dubbo: Service>

Importar paquetes en servicio pom.xml

 < -> <exclusions> <Sclusion> <MoupRiD> org.springframework </groupid> <artifactid> spring </artifactid> </extusion> <extusion> <proupid> org.jboss.netty </proupid> <arifactid> netty </artifactid> </exusion> </exusionsions >/Dependence> <Spendency> <MoupRid> org.apache.zookeeper </proupid> <artifactid> ZOOKEEPER </arfactid> </pendency> <pendency> <uproupid> com.github.sgroschupf </groupid> <arifactid> zkclient </arifactid> </pendency>

4 Cree un controlador de manager de primavera, que está en el mismo nivel que el proyecto agregado. Dependencias de importación.

La consuela necesita usar Dubbo para acceder al servicio publicado por la capa de servicio. Para usar el servidor Tomcat para la publicación, por supuesto, también se necesita SpringMVC.

xml

 <Spendencies> <!-Simplemente confíe en la interfaz de servicio-> <pendency> <MoupRid> com.qianfeng </groupid> <artifactid> sing-manager-interfaze </arfactid> <versión> 0.0.1-snapshot </verse> </dependency> <!-primavera! -> <Spendency> <MoupRoid> org.springframework </groupid> <artifactid> spring-Context </arfactiDID> <versever> $ {spring.version} </versión> </dependency> <epardency> <grupid> org.springframework </proupid> <artactid> spring-beans </artifactid> <lection> $ {{{{{» ring.version} </versión> </pendency> <epardency> <grupid> org.springframework </groupid> <artifactid> spring-webmvc </artifactid> <versión> $ {spring.version} </versión> </dependence> <epardency> <proupid> org.springframework </proupid> <artifactid> spring- spring- spring- spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- Spring- spring- Spring- Spring- jdbc </arifactid> <versers> $ {spring.version} </versión> </pendency> <Spendency> <uproupid> org.springframework </groupid> <artifactid> spring-aspects </arfactiCid> <Version> $ {spring.version} </verse> </dependency> <pendency> RK </groupid> <artifactid> spring-jms </artifactid> <versión> $ {spring.version} </versión> </pendency> <pendency> <uproupid> org.springframework </groupid> <artifactID> spring-context-support </artifactid> <proonsion> $ {spring.version} </version> </dependientes> JSP- Related-> <Spendency> <MoupRId> jstl </proupid> <artifactId> jstl </arfactId> </pendency> <ependency> <grupo> javax.servlet </groupId> <artifactId> servlet-api </a rtifactId> <Acpope> proporcionó </cope> </pendency> <pendency> <MoupRoD> javax.servlet </groupid> <artifactId> jsp-api </arfactid> <cope> proporcionó </cope> </pendency> <! Relacionado con Dubbo-> <Spendency> <MoupRId> Com.alibaba </groupid> <artifactid> dubbo </artifactid> <!-Excluir dependencias -> <exclusions> <Sclusion> <MoupRiD> org.springframework </groupid> <artifactid> spring </artifactid> </extusion> <extusion> <proupid> org.jboss.netty </proupid> <arifactid> netty </artifactid> </exusion> </exusionsions >/Dependence> <Spendency> <MoupRid> org.apache.zookeeper </proupid> <artifactid> Zookeeper </arfactid> </pendency> <pendency> <uproupid> com.github.sgroschupf </groupid> <artifactid> zkclient </artifactid> </pendency> </spendency> <DIARD> <GULTINS> <LEMPLEMIN> <MOURGEID> org.apache.tomcat.maven </proupid> <artifactid> tomcat7-maven-plugin </arfactid> <figuration> <port> 8081 </port> <path>/</path> </figuration> </glugin> </glugins> </stract>

spingmvc.xml

 <? xml versión = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" "" "" xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/s Chema/context "xmlns: mvc =" http://www.springframework.org/schema/mvc "xmlns: tx =" http: //www.springfr amework.org/schema/tx"xmlns:aop="http://www.springframework.org/schema/aop"xmlns:dubbo="http://c ode.alibabatech.com/schema/dubbo"xsi:schemalocation="http://www.springframework.org/schema/beanss http://www.springframework.org/schema/Beans/spring-Beans-4.2.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.4.2. http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springfframework.orgsschema/aop/ http://www.springframework.org/schema/aop/spring-aop-4.2.xsd http://code.alibabatech.com/schema/dubbo http://code.alibatech.com/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.2sd "> <context: component-scan base-package =" com.itqf.controller "> </context: componente> <mvc: annotation-riven> </mvc: annotation-riven> <bean> <propiedad name = "prefix" value = "/web-inf/jsp/"> </propiedad> <property name = "suffix" value = ". jsp"> </propiedad> </bean> <!-Especifique el proyecto-> <dubbo: name de la aplicación = "sping-manager-controller"/"< Centro-> <Dubbo: Registry Protocol = "Zookeeper" Dirección = "10.0.117.198:2181"> </dubbo: registro> <!-llamando al servicio-> <dubbo: interface = "com.itqf.service.itemservice" id = "itemservice"> </dubbo: reference> </behrems>

Diagrama estructural:

5 Crea un Spring-Common

Este es un lugar que necesito usar para colocar herramientas específicamente, que se utiliza para colocar algunas necesidades públicas; pom.xml

 <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0. http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>com.itqf</groupId> <artifactId>sing-parent</artifactId> <version>0.0.1-SNAPSHOT</version> </parent> <groupId>com.itqf</groupId> <artifactid> sing-common </artifactid> <versión> 0.0.1-snapshot </versions> <pendencies> <!-componente de operación de tiempo-> <pendency> <MoupRupid> joda-tiempo </groupid> <artifactid> joda-tiempo </artifactid> <versión> $ {joda-time.version} </versión> </spendency> <! Toole de dependencia <! Componentes-> <Spendency> <MoupRid> org.apache.commons </proupid> <artifactid> commons-lang3 </arifactid> <verserse> $ {commons-lang3.version} </versión> </pendency> <pendency> <grupoD> org.apache.commons </groupid> <artifact Id> commons-io </artifactid> <versión> $ {commons-io.version} </ververy> </dependence> <pendency> <proupid> commons-net </groupid> <artifactid> commons-net </artifactid> <versión> $ {commons-net.version} </versión> </spendency> <! Toolkit-> <Spendency> <MoupRid> com.fasterxml.jackson.core </groupid> <artifactid> jackson-databind </arfactid> <versión> $ {jackson.version} </versión> </pendency> </dependencias> </proyecto>

6 Prueba

De acuerdo, se ha construido este proyecto pseudo distribuido. El siguiente punto importante es que el proyecto matriz, el proyecto de agregación del manager de Spring-Spring y el Spring-Common deben instalarse en el almacén local. De lo contrario, se informará un error al comenzar el proyecto y el proyecto principal u otros proyectos no se pueden encontrar.

Dibujo final:

Resumir:

Después de varias horas de trabajo duro, finalmente lo construí. El viejo que iba a estar cansado y explotado. Si hay algún error o deficiencias, esté dispuesto a hacerlo.

Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.