Métodos para implementar a construção de projetos distribuídos em Java

1 distribuído

1.1 O que é distribuído

1. Um sistema distribuído deve ser um sistema composto por vários nós. Entre eles, os nós se referem a servidores de computador, e esses nós geralmente não são isolados, mas interoperáveis.
2. Nossos nós são implantados nesses nós conectados e suas operações serão coordenadas. Para os usuários, eles estão enfrentando um servidor que fornece os serviços de que precisam. De fato, esses serviços são um sistema distribuído composto por muitos servidores por trás deles; portanto, o sistema distribuído parece um supercomputador.

1.2 A diferença entre distribuídos e clusters

1. O cluster é a mesma unidade de sistema em diferentes servidores, por exemplo, uma unidade do sistema de login em diferentes servidores.
2. Sistema distribuído significa que diferentes departamentos do sistema se chamam em diferentes servidores.

Acontece que existe apenas um chef no pequeno restaurante, que corta legumes, lava legumes, prepara ingredientes e mexe todos eles. Mais tarde, havia mais clientes, e um chef na cozinha estava muito ocupado, então ele contratou outro chef. Ambos os chefs podem cozinhar os mesmos pratos. A relação entre esses dois chefs foi um cluster. Para deixar o chef se concentrar em cozinhar e fazer o melhor dos pratos, ele contratou um prato para ser responsável por cortar vegetais, preparar pratos e preparar ingredientes. O relacionamento entre o chef e o prato é distribuído, e um acompanhamento está muito ocupado, então ele contratou um prato, e o relacionamento entre o prato de dois acompanhamentos é um cluster.

2. Construa um projeto distribuído

Ferramentas de preparação: Eclipse, VMwarm Equipado com sistema CentOS7, Zookeeper ... O mais importante é uma máquina idosa de três anos.

Primeiro, crie um projeto Maven da classe pai e o método de embalagem é o POM.

Crie um projeto Maven da classe pai no Eclipse, e o método de embalagem é POM. Por que criar um projeto Maven da classe dos pais? Como você deseja usar este projeto MAVEN para gerenciar várias versões do pacote JAR, se a subclasse quiser diretamente o pacote JAR e a classe pai, você pode fazê -lo. 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 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.itqf</groupId> <artifactId>sing-parent</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>pom</packaging> <!-- Define the version of all jar Pacotes-> <Proadies> <nunit.version> 4.12 </junit.version> <pring.version> 4.2.4.Release </spring.version> <mybatis.version> 3.2.8 </mybatis.version> <mybatis.spring.version> 1.2.2 < /mybatis.spring.version><mybatis.paginator.version>1.2.15</mybatis.paginator.version><mysql.version>.1.32</mysql.version><slf4j.version>1.6.4plice 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 .version> <Verlet-Api.version> 2.5 </servlet-api.version> <jsp-api.version> 2.0 </jsp-api.version> <Joda-time.version> 2.5 </joda time.version> <commonns-lang3.ve Rsion> 3.3.2 </Commons-Lang3.version> <commons-io.version> 1.3.2 </Commons-io.version> <MonMoS-Net.version> 3.3 </Commons-Net.version> <PageHelper.version> 3.4. 2-FIX </pagehelper.version> <JSQLPARSER.VERSION> 0.9.1 </jsqlparser.version> <MonMoS-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> <zookeeper.version> 3.4.7 </zookeeper.version> <zkclient.versio n> 0.1 </zkclient.version> <Activemq.version> 5.11.2 </activemq.version> <freemarker.version> 2.3.23 </freemarker.version> <Quartz.version> 2.2.2 </quartz.version> </souperties> <!-Gerenciar pacotes JAR usados em todos os projetos, sem dependências reais-> <pendencyManagement> <pendências> <!-componente de operação de tempo-> <pendence> <voupid> joda-time </proupid>

2 Crie um projeto de agregação Maven.

2.1 Crie um projeto de agregação do Maven e herde o projeto pai.

Engenharia de agregação: a camada do controlador, a camada de visualização etc. no projeto pode ser formada independentemente em um projeto e, finalmente, integrado a um projeto quando finalmente é executado.

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 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelversion> <air> <puriDid> com.itqf </groupId> <TRAFACTID> singent </artifactid> <sipers> 0,0.1-SNAPSHOT <TRAFACTID> Sing-manager </ArtifactId> <Versão> 0.0.1-Snapshot </siers> <batyaging> pom </acheging> <pendências> <pendency> <purpiD> com.itqf </groupid> <TarifactId> Sing-Common </ArtifactId> <veripl> 0,0.1-snapshot <FUILD> <lugins> <lugin> <puperid> org.apache.tomcat.maven </groupid> <stifactId> tomcat7-maven-plugin </artifactId> <figuration> </port> 8083 </sot> </path>/////Path> </Moderin> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> </plugins> <Dodules> Sing-manager-Pojo </lodule> <odule> Sing-Manager-Interface </module> <odule> Sing-Manager-Service </module> <odule> Sing-Manager-Mapper </module> </modules> </juste>

2.2 Crie um módulo Maven no projeto de agregação e nomeie-o Sping-manager-pojo (camada de classe de entidade).

Pojo é um formato de jar normal e não precisa confiar no projeto pai.

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 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <airment> <puperid> com.itqf </groupid> <TRAFACTID> sing-manager </artifactid> <veriesse> 0,0.1-SNAPSHOT> <TarfactId> Sing-manager-Pojo </sutifactId> </ Project>

2.3 Crie um módulo Maven no projeto de agregação e nomeie a mola-gerente-preenchimento (camada dao). Confie no POJO no arquivo pom.xml. Como o método da camada de mapeador retorna um objeto de classe de entidade, Pojo precisa ser usado.

Importar pacotes de jar de dependência.

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 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <airment> <puperid> com.itqf </groupid> <TRAFACTID> sing-manager </artifactid> <veriesse> 0,0.1-SNAPSHOT> <stifactId> sing-manager-mapper </stutifactId> <!-dependência pojo-> <pendências> <pendence> <puperid> com.itqf </groupiD> <TRARFACTID> SING-MANAGER-POJO </Artifactid> <siets> My 0.1-snapshot </version> <! -> <Depencency> <roupidId> org.mybatis </groupId> <TROTIFACTID> mybatis </artifactId> <versão> $ {mybatis.version} </versão> </dependency> <pendencency> < groupId> org.mybatis </frugiD> <TRAFACTID> mybatis-spring </artifactId> <versão> $ {mybatis.spring.version} </versão> </dependency> <pendencence> <gro upid> com.github.miemiedev </groupiD> <stifactId> mybatis-paginator </artifactId> <version> $ {mybatis.paginator.version} </versão> </dependency> <de Pendency> <PuerpId> com.github.pagehelper </proupid> <stifactId> PageHelper </stutifactId> <versão> $ {PageHelper.version} </versão> </dependency> <!- Mysql-> <pendency> <puperid> mysql </groupiD> <TROTIFACTID> mysql-conector-java </artifactId> <versão> $ {mysql.version} </versão> </dependency> <!-conexão Pool-> <Depencency> <voupid> com.alibaba </frupidId> <TRAFACTID> druid </stutifactId> <versão> $ {druid.version} </versão> </dependency> </dependências> </project>

2.4 Crie uma interface do gerente da mola (interface) no projeto de agregação e coloque todas as interfaces de serviço em um projeto independente. Se o valor de retorno do método na interface for uma classe de entidade, o POJO será necessário. Portanto, depende do POJO xml em 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 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <airment> <puperid> com.itqf </groupid> <TRAFACTID> sing-manager </artifactid> <veriesse> 0,0.1-SNAPSHOT> <TarifactId> Sing-manager-interface </ArtifactId> <pendências> <pendence> <puperid> com.itqf </groupiD> <TRARFACTID> SING-MANAGER-POJO </ArtifactId> <Bersion> 0.0.1-Snapshot </sipers> </dependência> </dependências> </Project>

2.5 Crie o manager de primavera (classe de implementação da interface) no projeto de agregação. O método de embalagem é guerra

Como a camada do controlador é separada da camada de serviço, ao executar e iniciar, o controlador e o serviço devem ser publicados separadamente usando o Tomcat, e todos os arquivos de configuração necessários no projeto de agregação são colocados no serviço, para que todos os arquivos de configuração sejam carregados e integrados quando o tomcat for iniciado.

1. O serviço precisa usar uma interface, por isso depende da interface-manager-manager-interface.
2. O serviço precisa usar o POJO e também precisa chamar Mapper, para que você possa confiar diretamente no Mapper, pensando que o Mapper já confiou no POJO (entrega de dependência) .
3. O serviço precisa ser gerenciado pela primavera, deixe a primavera criar objetos para o serviço
4. O serviço requer o pacote Dubbo (introduzido posteriormente em Dubbo)
5. O serviço precisa usar o SOA e publicar o serviço como um serviço.

Arquivo de configuração

SqlMapConfig.xml

 <? xml versão = "1.0" coding = "utf-8"?> <! Doctype ConfigurationPublic "-// mybatis.org//dtd config 3.0/pt" "http://mybatis.org/dtd/mybatis-3ation>

db.properties

 db.Driver = com.mysql.jdbc.driverdb.url = jdbc: mysql: // localhost: 3306/taotao?

applicationContext-tx.xml

 <? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/s química/contexto "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/beans 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.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 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 "> <beian" tSManager "> <er property>" DataSurce " <tx: conselhos id = "conselhos" transação-manager = "txManager"> <tx: atributes> <tx: método name = "add*" propagation = "requerir"/> <tx: name método = "salvar*" propagation = "requerir"/> <tx: name = "insert*" propagação "requerido"/> "/> <t:" "/> <tx: name =" insert*"propagation =" requerido "/>"/> <t: "" <tx: método name = "update*" propagation = "requerir"/> <tx: método name = "del*" propagation = "requerir"/> <tx: método name = "find*" propagation = "suporta" read-only = "true"/> <tx: name = "get*" propagation = "suportes"/readny = "" <aop: config> <aOP: consultor aconselhamento-ref = "aconselha" Pointcut = "Execution (*com.itqf.service ..*.*(..))"/> </aop: config> </sheans>

applicationContext-dao.xml

 <? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/Context" Xmlns: mvc = "http :/schema/Context" Xmlns: Amework.org/schema/mvc"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xsi:schemalocation="http://www.springframework.org/schema/beans 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.2.xsd 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 "> <Contexto: Property-placeholder Location =" ClassPath: Resource/*. name = "url" value = "$ {db.url}"> </propriedade> <propriedade name = "nome de usuário" value = "$ {db.username}"> </imobiliário> <names name = "value" value = "$ {db.password}"> </propriedade> <nome do nome = "" maxactativo "" "" 10 {db.password} "> </imobiliário> <nome" "" maxactive "" "" "10 {db.password}"> </imobiliário> <name = "maxactativo" "10" 10 "10 {DB. </bean> <ean> <propriedade name = "DataSource" ref = "DataSource"> </Property> <propriedade name = "configLocation" value = "classPath: mybatis/sqlmapconfig.xml"> </oiltering> </shean> <ean> <wean> <weanan)

applicationContext-service.xml

 <? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/schema/Context" Xmlns: mvc = "http :/schema/Context" Xmlns: Amework.org/schema/mvc"xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"xsi:schemalocation="http://www.springframework.org/schema/beans 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.2.xsd 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 "> <Contexto: Componente-Scan-Package =" com.itqf.service "> </Context: Component-Scan> </i Beans>

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 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelVersion> <air> <puriDid> com.qianfeng </roupidId> <TarifactId> sing-manager </stifactid> <erpresul> 0.1-SNAPSHOTTHTHOTHTHTHOTH </Artifactid> <erpresul> 0.1-SNAPSHOTME </Artifactid> 0.1-SNAPSHOT> <TRAFACTID> SING-MANAGER-SERVICE </ArtifactId> <batyaging> war </acheging> <pendes> <pendency> <purbrouDId> com.qianfeng </groupiD> <TRAFACTID> Sing-manager-interface </ArtifactId> <Versão> 0,0.1-SnapShot </Version> </Dependência> <TarfactId> Sing-manager-mapper </sutifactId> <versão> 0.0.1-snapshot </sipers> </dependency> <!-Spring -> <Depencency> <voundId> org.springframework </groupId> <TROTIFACTID> Spring-Context </ArtifactId> <versão> $ {spring.version} </version> </dependency> <pendency> <voundid> org.springFramework </purpuld> <Tristifactid> Spring-BEANS </ArtiftLestiftyBid> Springfrust </ArtiftLestiftyTiftLestert </ArtiftLestiftiFTIFTIF </ArtiftLestiftiFTIF) ring.version} </versão> </dependency> <pendency> <puperid> org.springframework </frugiD> <TRAFACTID> spring-webmvc </artifactId> <versão> $ {spring.version} </sipers> </dependency> <Puperid> ou springfamerwrinworkswrinwork- jdbc </artifactId> <versão> $ {spring.version} </versão> </dependency> <pendence> <puperid> org.springframework </groupid> <ArtifactId> spring-aspets </ArtifactId> <versão> {spring.version} </versão </dependência> rk </proupId> <TarifactId> spring-jms </artifactId> <versão> $ {spring.version} </versão> </dependency> <pendesency> <voupid> org.springframework </groupid> <stifactId> spring-context-support </stifactId> <versão> $ {Version> spring-context </artifactId> <siers> US $ {versão> </dependences> </Project>

Estrutura final de engenharia

3 Use Dubbo para publicar o serviço

Pense primeiro?

Sites de shopping como Taobao e JD podem não apenas fazer login do lado do PC, mas também do lado do celular. Como é implementado? Escrever dois controladores? Definitivamente não é. Quem não terá nada para fazer quando você não tiver nada para fazer? Então isso requer o uso da SOA (arquitetura orientada a serviços). Quando escrevemos um projeto usando distribuídos, haverá muitos sistemas para se ligar. Se você ligar de volta e para trás, a estrutura do código será muito confusa. Aqui usamos o Dubbo para resolver o problema de muitos serviços de publicação e não sermos claros sobre isso.

O que é SOA

A SOA é um método de design que inclui vários serviços, e os serviços acabarão por fornecer uma série de funções por meio da cooperação. Geralmente, um serviço existe de forma independente em um processo do sistema operacional. Os serviços se comunicam através da rede, em vez de chamadas em processo.

For example, you have many services now: news services (providing news release, viewing, modification, deletion), order services (order addition, order modification, order viewing, order deletion, etc.) financial services (revenue, expenditure, statistics, etc.) employee services (new, modification, viewing, statistics) attendance services (sign-in, sign-in, return, export, statistics, etc.) sales services (sell reporting, sales statistics.)

DUBBO

O que é Dubbo (uma ferramenta de gerenciamento para o Centro de Programação e Governança de Recursos)

Com o desenvolvimento da Internet, a escala dos aplicativos de sites foi continuamente expandida e as arquiteturas de aplicativos verticais convencionais não podem mais lidar com ele. Arquiteturas de serviço distribuídas e arquiteturas de computação móvel são imperativas. Um sistema de governança é urgentemente necessário para garantir a evolução ordenada da arquitetura.

Arquitetura de aplicativo único

1. Quando o tráfego do site é pequeno, é necessário apenas um aplicativo para implantar todos os recursos juntos para reduzir os nós e os custos de implantação.
2. No momento, a estrutura de acesso a dados (ORM) usada para simplificar a carga de trabalho de adição, exclusão, modificação e verificação é a chave.

Arquitetura de Aplicativo Vertical

1. À medida que o número de visitas aumenta gradualmente, a aceleração trazida por um único aplicativo para aumentar a máquina se torna cada vez menor, e a aplicação é dividida em várias aplicações irrelevantes para melhorar a eficiência.
2. Nesse ponto, a estrutura da web (MVC) usada para acelerar o desenvolvimento da página front-end é fundamental.

Arquitetura de Serviço Distribuída

1. Como existem cada vez mais aplicações verticais, as interações entre as aplicações são inevitáveis. Os serviços principais são extraídos como serviços independentes e um centro de serviço estável é formado gradualmente, para que os aplicativos front-end possam responder às mudanças nas demandas do mercado mais rapidamente.
2. No momento, a estrutura de serviço distribuída (RPC) usada para melhorar a reutilização e a integração do serviço é a chave.

Arquitetura de computação de fluxo

1. À medida que mais e mais serviços estão disponíveis, problemas como avaliação de capacidade e desperdício de pequenos recursos de serviço estão gradualmente emergentes, um centro de despacho precisa ser adicionado para gerenciar a capacidade de cluster em tempo real com base na pressão de acesso para melhorar a utilização do cluster.
2. Nesse ponto, o Centro de Agendamento e Governança de Recursos (SOA) para melhorar a utilização da máquina é fundamental.

Construção do ambiente de Dubbo:

Descrição da função do nó:

1. Provedor: o provedor de serviços que expõe o serviço.
2. Consumidor: o consumidor de serviço que chama o serviço remoto.
3. Registro: O Centro de Registro para Registro e Descoberta de Serviços.
4. Monitor: Centro de Monitoramento que conta o número de chamadas e o tempo de chamada do serviço.
5. Container: o serviço executa o contêiner.

Chamada de descrição do relacionamento:

1. O contêiner de serviço é responsável por iniciar, carregar e executar o provedor de serviços.
2. Quando o provedor de serviços inicia, ele registra os serviços que ele fornece com o Centro de Registro.
3. Quando os consumidores do serviço começarem, assine os serviços necessários para o registro.
4. O Centro de Registro retorna a lista de endereços do provedor de serviços ao consumidor. Se houver alguma alteração, o Centro de Registro levará os dados de alteração ao consumidor com base na conexão longa.
5. Para atender os consumidores, com base no algoritmo de balanceamento de carga suave, selecione um provedor para chamá -lo. Se a chamada falhar, selecione outra chamada. Os consumidores e provedores de serviço acumulam o número de chamadas e as chamadas na memória e enviam estatísticas para o centro de monitoramento regularmente a cada minuto.

Aqui chegamos principalmente ao Centro de Registro (Registro), e usamos o Zookeeper para atuar como centro de registro.

Implantar o registro no ambiente Linux, Zookeeper

É claro que o primeiro passo é ativar a máquina virtual, então farei isso no CentOS7.

Obtenha um pacote compactado on-line, o meu é Zookeeper-3.4.6.tar.gz

Cole o diretório in /opt e descomprima. (O ambiente JDK é necessário. Se não houver um ambiente JDK, instale um JDK primeiro)

Digite o diretório Zookeeper-3.4.6 e crie uma pasta chamada dados.

Renomear zoo_sample.cfg no diretório ./conf para zoo.cfg modificar o atributo de dados em zoo.cfg: datadir =/opt/zookeeper-3.4.6/dados

Etapa 7:

1. Comece o Zookeeper.
2. Iniciar: ./ zkserver.sh Start
3. Fechar: ./ zkserver.sh Stop
4. View Status: ./ ZkSserver.sh Status

Observe que depois que o Zookeeper é iniciado, você deve desligar o firewall !!! É isso.

Adicionar arquivo de configuração ao serviço ApplicationContext-Service.xml para publicar o serviço

 <!-- Use dubbo to publish the service --> <!-- Indicate the project where the service is located --> <dubbo:application name="sing-manager"/> <!-- Indicate the registry address is the IP address in Linux plus the port number, and the default port number of zookeeper is 2181 --> <dubbo:registry protocol="zookeeper" address="10.0.117.198:2181" > </dubbo: Registry> <!-Exponha o serviço a um determinado número da porta da porta, selecione uma porta que não esteja ocupada-> <Dubbo: protocolo name = "dubbo" porta = "20888"> </dubbo: protocolo> <!-Exponha o serviço a um determinado número da porta, selecione uma porta que não é ocupada-> Port = "20888"> </dubbo: protocolo> <!-Ref é o nome do objeto de serviço criado pelo contêiner da mola-> <dubbo: serviço interface = "com.itqf.service.itemservice" ref = "itenserviceImpl" timeout = "6000000"> </dubbo: serviço>

Importar pacotes no serviço pom.xml

 <!-relacionado ao dubbo-> <pendency> <voundid> com.alibaba </groupiD> <TRARFACTID> DUBBO </ArtifactId> <!-exclua dependências -> <clusions> <clusion> <puperid> org.springframework </groupiD> <TRAFACTID> Spring </stutifactId> </clusion> <cclusion> <puperId> org.jboss.netty </Groupid> <Tarfactid> Netty </Artifactid> </exclusões> </exclusões >/dependency> <pendency> <voundid> org.apache.zookeeper </foupidId> <ArtifactId> Zookeeper </ArtifactId> </pendesicency> <pendence> <puperid> com.github.sgroschupf </frupId> <stifactId> zkclient </Artifactid> </Dependência

4 Crie um controlador de gerente de primavera, que está no mesmo nível do projeto agregado. Importar dependências.

O consolador precisa usar o Dubbo para acessar o serviço publicado pela camada de serviço. Para usar o servidor Tomcat para publicação, é claro, também é necessário o SpringMVC.

xml

 <Dependences> <!-Basta confiar na interface de serviço-> <pendency> <voundid> com.qianfeng </groupiD> <TRAFACTID> sing-manager-interface -> <Depencency> <voundId> org.springframework </groupId> <TROTIFACTID> Spring-Context </ArtifactId> <versão> $ {spring.version} </version> </dependency> <pendency> <voundid> org.springFramework </purpuld> <Tristifactid> Spring-BEANS </ArtiftLestiftyBid> Springfrust </ArtiftLestiftyTiftLestert </ArtiftLestiftiFTIFTIF </ArtiftLestiftiFTIF) ring.version} </versão> </dependency> <pendency> <puperid> org.springframework </frugiD> <TRAFACTID> spring-webmvc </artifactId> <versão> $ {spring.version} </sipers> </dependency> <Puperid> ou springfamerwrinworkswrinwork- jdbc </artifactId> <versão> $ {spring.version} </versão> </dependency> <pendence> <puperid> org.springframework </groupid> <ArtifactId> spring-aspets </ArtifactId> <versão> {spring.version} </versão </dependência> rk </roupidId> <ArtifactId> spring-jms </artifactId> <versão> $ {spring.version} </versão> </dependency> <pendency> <voundid> org.springframework </siPergId> <stifactId> spring-context-support </artifactId> <versão> $ { JSP relacionado-> <Depencency> <puperid> jstl </groupId> <TRARFACTID> jstl </storkactid> </dependency> <pendencency> <voundid> javax.servlet </rouprouid> <TRAFACTID> servlet-api </a rtifactId> <cope> fornecido </cope> </dependency> <pendencency> <voundid> javax.servlet </groupiD> <TRATIFACTID> jsp-api </artifactId> <copo> fornecido </scope> </dependency> <!-!-! Dubbo relacionado-> <Depencency> <voundid> com.alibaba </frugiD> <ArtifactId> dubbo </artifactId> <!-exclua dependências -> <clusions> <clusion> <puperid> org.springframework </groupiD> <TRAFACTID> Spring </stutifactId> </clusion> <cclusion> <puperId> org.jboss.netty </Groupid> <Tarfactid> Netty </Artifactid> </exclusões> </exclusões >/dependency> <pendency> <voundid> org.apache.zookeeper </proupId> <TRAFACTID> Zookeeper </stutifactId> </dependency> <pendence> <puperid> com.github.sgroschupf </groupId> <TRATIFACTID> zkclient </sorfactid> </dependência <build><plugins><plugin><groupId>org.apache.tomcat.maven</groupId><artifactId>tomcat7-maven-plugin</artifactId><configuration><port>8081</port><path>/</path></configuration></plugin></plugins> </build>

spingmvc.xml

 <? xml versão = "1.0" coding = "utf-8"?> <Beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http:/wwww.w3 xmlns: p = "http://www.springframework.org/schema/p" xmlns: context = "http://www.springframework.org/s química/contexto "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/beans 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.2.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.2.xsd http://www.springframework.org/schema http://www.springframework.org/schema/aop/spring-aop-4.2.xsd 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 "<contexto: component-cack/package =" com.itqf.Controller "<Context-Cenent-scan/" "com.itqf.itxtr". <mvc: anotação-driven> </mvc: anotação-driven> <bean> <propriedade name = "prefix" value = "/web-inf/jsp/"> </property> <propriedades name = "sufix" value = ". Centro de Registro-> <Dubbo: Registry Protocol = "Zookeeper" endereço = "10.0.117.198:2181"> </dubbo: Registry> <!-Calling the Service-> <Dubbo: Referência Interface = "com.itqf.serv.ItemSevice" Id = "Itens Service">

Diagrama estrutural:

5 Crie um comando de primavera

Este é um lugar que preciso usar para colocar ferramentas especificamente, que é usado para colocar algumas necessidades 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 http://maven.apache.org/xsd/maven-4.0.0.xsd "> <ModelVersion> 4.0.0 </modelversion> <air> <puriDid> com.itqf </groupId> <TRAFACTID> singent </artifactid> <sipers> 0,0.1-SNAPSHOT <TRAFACTID> SING-COMMON </STIFACTID> <Versão> 0.0.1-Snapshot </sisters> <pendences> <!-Componente de operação de tempo-> <pendency> <voupId> joda-the-the </proupid> <DorifactId> joda-time </stifactId> </versão> $ {joda-time.version> Componentes-> <pendency> <voundid> org.apache.commons </groupiD> <TRAFACTID> Commons-lang3 </stifactId> <Versão> $ {commons-lang3.version} </sipers> </dependency> <pendence> <puadeid> org.apache.Commons </GroupId> Artift Id> commons-io </stifactId> <versão> $ {Commons-IO.version} </siers> </dependency> <pendency> <purbrouDId> commons-net </foupid> <TRARFACTID> commons-net </artifactId> <versão> {commonns-net.version} </version> </dependent> </dependência> </dependência> </incence> Toolkit-> <pendency> <puperid> com.fasterxml.jackson.core </groupid> <TRAFACTID> Jackson-Databind </stifactId> <Version> $ {Jackson.version} </versão> </dependency> </dependências> </Project>

6 teste

Ok, este projeto pseudo-distribuído foi construído. O próximo ponto importante é que o projeto pai, o projeto de agregação do gerente da primavera e o comando da primavera precisam ser instalados no armazém local. Caso contrário, um erro será relatado ao iniciar o projeto e o projeto pai ou outros projetos não poderão ser encontrados.

Desenho final:

Resumir:

Depois de várias horas de trabalho duro, finalmente o construí. O velho que ficaria cansado e explodiu. Se houver erros ou deficiências, esteja disposto a fazê -lo.

O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.