复习springMVC+hibernate+dubboProvider搭建框架

最新推荐文章于 2021-12-12 11:59:22 发布
最新推荐文章于 2021-12-12 11:59:22 发布
阅读量823 收藏
点赞数 1
分类专栏： maven+springMVC+hibernate+dubb 文章标签： springMVC+hibernate框
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/annghi/article/details/59486608
版权

ps:这个和 dubboConsumer是一套的，所以和上面一样，没有测试hibernate，等以后什么时候抽空测一把。

1.项目结构


2.配置文件

spring-dubbo.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="
	http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
	http://www.springframework.org/schema/aop 
	http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
	http://www.springframework.org/schema/context 
	http://www.springframework.org/schema/context/spring-context-3.1.xsd
    http://code.alibabatech.com/schema/dubbo
    http://code.alibabatech.com/schema/dubbo/dubbo.xsd" >

	<!-- 提供方应用信息，用于计算依赖关系 -->
	<dubbo:application name="${dubbo.application}" /> 
	<!--  需要注册服务-->
 	<dubbo:registry protocol="zookeeper" address="${dubbo.registry}" />
	<!-- 配置注册中心 /-->
	<!--<dubbo:registry address="N/A" />-->
 	
 	<!-- 用dubbo协议在20880端口暴露服务 direct:所有消息都不派发到线程池，全部在IO线程上直接执行 -->
	<dubbo:protocol name="dubbo" port="${provider.protocol}"  accesslog="${provider.accesslog}" />
	
	<!-- 声明需要暴露的服务接口  retries:关闭写入方法的重试-->
	
	<dubbo:service interface="com.ylz.dubbo.server.UserInfoServer" ref="UserInfoServer" retries="${provider.retries}" timeout="${provider.timeout}" version="${provider.version}"/>
	

</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>
	<groupId>com.ylz</groupId>
	<artifactId>provider</artifactId>
	<version>0.0.1</version>
	<packaging>jar</packaging>
	<name>dubboProviderTest Maven</name>
	<url>http://maven.apache.org</url>
	<description>dubboProviderTest Maven</description>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring.version>3.2.0.RELEASE</spring.version>
		<hibernate.version>4.3.8.Final</hibernate.version>
		<jackson.version>2.5.0</jackson.version>
	</properties>
	<build>
		<finalName>provider_${project.version}</finalName>
		<sourceDirectory>src/main/java</sourceDirectory>
		<resources>
			<resource>
				<targetPath>${project.build.directory}/classes</targetPath>
				<directory>src/main/resources</directory>
				<filtering>true</filtering> 
				<includes>
					<include>spring*.xml</include>
					<include>*.properties</include>
				</includes>
			</resource>
		</resources>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-war-plugin</artifactId>
				<configuration>
					<failOnMissingWebXml>false</failOnMissingWebXml>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
		<!-- 引入本地工程 -->
		<dependency>
			<groupId>com.ylz</groupId>
			<artifactId>dto</artifactId>
			<version>0.0.1</version>
		</dependency>
		<dependency>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.6</version>
		</dependency>
		<dependency>
			<groupId>commons-beanutils</groupId>
			<artifactId>commons-beanutils</artifactId>
			<version>1.8.3</version>
		</dependency>


		<!-- spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
			<scope>test</scope>
		</dependency>


		<!-- spring aop编程 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>3.2.0.RELEASE</version>
		</dependency>


		<!-- 关系型数据库整合时需配置 如hibernate jpa等 -->
		<!-- hibernate -->
		<dependency>
			<groupId>org.hibernate.javax.persistence</groupId>
			<artifactId>hibernate-jpa-2.0-api </artifactId>
			<version>1.0.1.Final</version>
		</dependency>


		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>4.1.9.Final</version>
		</dependency>


		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-ehcache</artifactId>
			<version>4.1.9.Final</version>
		</dependency>


		<!-- c3p0数据源 -->
		<dependency>
			<groupId>com.mchange</groupId>
			<artifactId>c3p0</artifactId>
			<version>0.9.5-pre10</version>
		</dependency>


		<!-- 使用Spring配置 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>4.0.2.RELEASE</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jms</artifactId>
			<version>${spring.version}</version>
		</dependency>


		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.0.2.RELEASE</version>
		</dependency>


		<!-- mysql连接 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.34</version>
		</dependency>


		<!-- servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>3.1.0</version>
			<type>jar</type>
			<scope>provided</scope>
		</dependency>


		<!-- json -->
		<!-- <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> 
			<version>1.2.3</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> 
			<artifactId>jackson-annotations</artifactId> <version>${jackson.version}</version> 
			</dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> 
			<artifactId>jackson-core</artifactId> <version>${jackson.version}</version> 
			</dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> 
			<artifactId>jackson-databind</artifactId> <version>${jackson.version}</version> 
			</dependency> -->


		<dependency>
			<groupId>com.fasterxml.jackson.dataformat</groupId>
			<artifactId>jackson-dataformat-xml</artifactId>
			<version>2.2.3</version>
		</dependency>


		<!-- log4j -->
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.16</version>
		</dependency>


		<!-- dubbo zookeeper 相关 -->
		<dependency>
			<groupId>com.101tec</groupId>
			<artifactId>zkclient</artifactId>
			<version>0.4</version>
		</dependency>
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>dubbo</artifactId>
			<version>2.5.2</version>
			<exclusions>
				<exclusion>
					<artifactId>spring</artifactId>
					<groupId>org.springframework</groupId>
				</exclusion>
			</exclusions>
		</dependency>


		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<version>3.4.6</version>
			<exclusions>
				<exclusion>
					<artifactId>jmxtools</artifactId>
					<groupId>com.sun.jdmk</groupId>
				</exclusion>
				<exclusion>
					<artifactId>jmxri</artifactId>
					<groupId>com.sun.jmx</groupId>
				</exclusion>
				<exclusion>
					<artifactId>jms</artifactId>
					<groupId>javax.jms</groupId>
				</exclusion>
			</exclusions>
		</dependency>


	</dependencies>
</project>


spring.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd  
            http://www.springframework.org/schema/context  
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/tx   
       	 	http://www.springframework.org/schema/tx/spring-tx-4.1.xsd  
        	http://www.springframework.org/schema/aop   
        	http://www.springframework.org/schema/aop/spring-aop-4.1.xsd"> 
        	  
    <!-- 加载配置文件 -->  
   	<bean id="propertyConfigurer" class="com.ylz.CustomConfig">
		<property name="locations">
			<list>
				<value>classpath:config.properties</value>
			</list>
		</property>
	</bean> 
    <!-- 扫描service自动注入为bean -->  
    <context:component-scan base-package="com.ylz" />  
  
	<!-- 开启AOP监听 只对当前配置文件有效 -->
	<aop:aspectj-autoproxy expose-proxy="true"/>
	
<!-- 导入hibernate服务配置 -->
	<import resource="classpath:hibernate.xml" />
<!-- 导入dubbo服务配置 -->
<!-- 	<import resource="classpath:spring-dubbo.xml" /> -->
</beans>


hibernate.xml

<?xml version="1.0" encoding="UTF-8"?>  
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:tx="http://www.springframework.org/schema/tx"  
    xmlns:aop="http://www.springframework.org/schema/aop"  
    xsi:schemaLocation="http://www.springframework.org/schema/beans  
            http://www.springframework.org/schema/beans/spring-beans-4.1.xsd  
            http://www.springframework.org/schema/context  
            http://www.springframework.org/schema/context/spring-context-4.1.xsd
            http://www.springframework.org/schema/tx   
       	 	http://www.springframework.org/schema/tx/spring-tx-4.1.xsd  
        	http://www.springframework.org/schema/aop   
        	http://www.springframework.org/schema/aop/spring-aop-4.1.xsd"> 
        	  
   <!-- 配置hibernate -->  
    <!-- 配置数据源 c3p0 -->  
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"  
        destroy-method="close">  
        <property name="driverClass" value="${jdbc.driver}" />  
        <property name="jdbcUrl" value="${jdbc.url}" />  
        <property name="user" value="${jdbc.username}" />  
        <property name="password" value="${jdbc.password}" />  
  
        <!-- 请求超时时间 -->  
        <property name="checkoutTimeout" value="30000" />  
        <!-- 每60秒检查所有连接池中的空闲连接。默认值: 0，不检查 -->  
        <property name="idleConnectionTestPeriod" value="30" />  
        <!-- 连接数据库连接池最大空闲时间 -->  
        <property name="maxIdleTime" value="30" />  
        <!-- 连接池初始化连接数 -->  
        <property name="initialPoolSize" value="5" />  
        <property name="minPoolSize" value="5" />  
        <property name="maxPoolSize" value="20" />  
        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。默认值: 3 -->  
        <property name="acquireIncrement" value="5" />  
    </bean>
    
    <!-- 配置hibernate的SessionFactory -->  
    <bean id="sessionFactory"  
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
        <!-- 注入数据源 相关信息看源码 -->  
        <property name="dataSource" ref="dataSource" />  
        <!-- hibernate配置信息 -->  
        <property name="hibernateProperties">  
            <props>  
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>  
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
                <prop key="hibernate.format_sql">${hibernate.format_sql}</prop>  
                <prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>  
  
                <!-- 开启二级缓存 ehcache -->  
                <prop key="hibernate.cache.use_second_level_cache">${hibernate.cache.use_second_level_cache}</prop>  
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>  
                <prop key="hibernate.cache.region.factory_class">${hibernate.cache.region.factory_class}</prop>  
                <prop key="hibernate.cache.provider_configuration_file_resource_path">${hibernate.cache.provider_configuration_file_resource_path}  
                </prop>  
            </props>  
        </property>  
        <!-- 扫描hibernate注解配置的entity -->  
        <property name="packagesToScan" value="com.ylz" />  
    </bean>  
  
    <!-- 配置事务管理器 -->  
    <bean id="transactionManager"  
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
        <property name="sessionFactory" ref="sessionFactory" />  
    </bean>  
  
   	<!-- 开启注解事务 只对当前配置文件有效 -->
	<tx:annotation-driven transaction-manager="txManager" order="100"/>


	<bean id="txManager" class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory"/>
	</bean>
</beans>

 


config.properties

#applicationconfigs

#jdbcc3p0config
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/css?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

#hibernateconfig
hibernate.dialect=org.hibernate.dialect.MySQLDialect
hibernate.show_sql=true
hibernate.format_sql=false
hibernate.hbm2ddl.auto=update
#
hibernate.cache.use_second_level_cache=true
hibernate.cache.use_query_cache=true
hibernate.cache.region.factory_class=org.hibernate.cache.ehcache.EhCacheRegionFactory
hibernate.cache.provider_configuration_file_resource_path=ehcache.xml

#listenerstopport
stop.port=10882

log4j.properties

### set log levels ###  
log4j.rootLogger = INFO , C , D , E   
  
### console ###  
log4j.appender.C = org.apache.log4j.ConsoleAppender  
log4j.appender.C.Target = System.out  
log4j.appender.C.layout = org.apache.log4j.PatternLayout  
log4j.appender.C.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n  
  
### log file ###  
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.D.File = ../logs/springmvc_hibernate_demo.log  
log4j.appender.D.Append = true  
log4j.appender.D.Threshold = INFO   
log4j.appender.D.layout = org.apache.log4j.PatternLayout  
log4j.appender.D.layout.ConversionPattern = [springmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n  
  
### exception ###  
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender  
log4j.appender.E.File = ../logs/springmvc_hibernate_demo_error.log   
log4j.appender.E.Append = true  
log4j.appender.E.Threshold = ERROR   
log4j.appender.E.layout = org.apache.log4j.PatternLayout  
log4j.appender.E.layout.ConversionPattern = [sspringmvc_hibernate_demo][%p] [%-d{yyyy-MM-dd HH:mm:ss}] %C.%M(%L) | %m%n

CustomConfig.java

package com.ylz;

import java.util.HashMap;  
import java.util.Map;  
import java.util.Properties;  
  
import org.springframework.beans.BeansException;  
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;  
import org.springframework.beans.factory.config.PropertyPlaceholderConfigurer;  
  
/**
 * 用PropertyPlaceholderConfigurer在加载上下文的时候暴露properties
 * @author Auser
 *
 */
public class CustomConfig extends PropertyPlaceholderConfigurer {  
  
    private static Map<String, String> ctxPropertiesMap;  
  
    @Override  
    protected void processProperties(ConfigurableListableBeanFactory beanFactory,  
            Properties props)throws BeansException {  
  
        super.processProperties(beanFactory, props);  
        //load properties to ctxPropertiesMap  
        ctxPropertiesMap = new HashMap<String, String>();  
        for (Object key : props.keySet()) {  
            String keyStr = key.toString();  
            String value = props.getProperty(keyStr);  
            ctxPropertiesMap.put(keyStr, value);  
        }  
    }  
  
    //static method for accessing context properties  
    public static String getContextProperty(String name) {  
        return ctxPropertiesMap.get(name);  
    }  
}

手动启动spring框架
StartServer.java

package com.ylz;





import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

import org.apache.commons.lang.math.NumberUtils;
import org.apache.log4j.Logger;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ylz.tools.util.StringUtil;


/**
 * <一句话功能简述>
 * <功能详细描述>
 * 
 * @author  Administrator
 * @version  [版本号, 2015-4-15]
 * @see  [相关类/方法]
 * @since  [产品/模块版本]
 */
public class StartServer
{

	private static final Logger logger = Logger.getLogger(StartServer.class);

	@SuppressWarnings("resource")
	public static void main(String[] args) {
		try {
			final ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
					new String[] { "spring.xml" });
			context.start();
			// 监听端口
			String port = CustomConfig.getContextProperty("stop.port");
			System.out.println(port);
			if (StringUtil.isEmpty(port) || !NumberUtils.isNumber(port)) {
				// 正常退出程序
				System.exit(0);
			}

			// 启动监听程序
			Listener listener = new Listener(Integer.parseInt(port));
			Thread run = new Thread(listener);

			run.start();
		} catch (Exception e) {
			// TODO: handle exception
			logger.error(e.getMessage(), e);
			System.exit(0);
		}
	}
}

class Listener implements Runnable
{
    
    private static final Logger logger = Logger.getLogger(StopServer.class);
    
    ServerSocket server = null;
    
    Socket socket = null;
    
    InputStream in = null;
    
    BufferedReader br = null;
    
    final int port;
    
    protected Listener(int port)
    {
        this.port = port;
    }
    
    @Override
    public void run()
    {
        
        try
        {
            server = new ServerSocket(port);
            logger.info("Server stop listener == > \t port = > " + port);
            socket = server.accept();
            logger.info("Server stop action   == > \t port = > " + port);
            in = socket.getInputStream();
            //InputStreamReader将字节流转化为字符流
            br = new BufferedReader(new InputStreamReader(in));
            //行读取客户端数据
            String info = br.readLine();
            logger.info(info);
        }
        catch (IOException e)
        {
            logger.error(e);
        }
        finally
        {
            close(server, socket, in, br);
            
            try
            {
                // 此处可以执行关闭数据库连接等操作
                Thread.sleep(5000l);
            }
            catch (InterruptedException e)
            {
                logger.error(e);
            }
            System.exit(0);
        }
    }
    
    private void close(ServerSocket server, Socket socket, InputStream in, BufferedReader br)
    {
        try
        {
            if (null != br)
                br.close();
        }
        catch (IOException e)
        {
            logger.error(e);
        }
        try
        {
            if (null != in)
                in.close();
        }
        catch (IOException e)
        {
            logger.error(e);
        }
        try
        {
            if (null != socket && !socket.isClosed())
                socket.close();
        }
        catch (IOException e)
        {
            logger.error(e);
        }
        try
        {
            if (server != null && !server.isClosed())
                server.close();
        }
        catch (IOException e)
        {
            logger.error(e);
        }
    }
}




annghi
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring，mybatis，hibernate，activemq，redis，dubbo的集成
06-17
整合了spring，mybatis，hibernate，activemq，redis，dubbo的一个工程，项目管理工具是maven，数据库用的mysql。
最简单的dubbo demo(SpringMVC+hibernate+Spring+dubbo+ZooKeeper+redis+Maven)
w19930104q的博客
07-24 1841
SpringMVC+hibernate+Spring+dubbo+ZooKeeper+redis+Maven
Dubbox+Redis3.0+Spring+Hibernate+zookeeper实现消息推送核心搭建
青年IT男
12-30 179
这里在开始搭建环境之前请搭建先熟悉了解Dubbox、Redis、Zookeeper.... 并且安装Redis、Zookeeper      下面进入主题首先我们需要下载Dubbox相关代码链接地址：https://github.com/dangdangdotcom/dubbox这里使用Eclipse git工具下载源代码 这里我们具体使用的是 dubbo-demo-provider这个项目...
maven+spring mvc+hibernate+dubbo的demo
12-11
maven+spring mvc+hibernate+dubbo的demo,运行前请修改resources/config.properties下的数据配置
基于dubbo和hibernate的例子
08-07
基于dubbo和hibernate的分层例子，并有一个dubbo client模拟消费者
Spring+SpringMVC+Hibernate+JSP框架搭建
01-01
"Spring+SpringMVC+Hibernate+JSP框架搭建"就是一个经典的Java Web开发解决方案，它整合了四个核心组件来实现全面的后端功能和用户界面交互。下面我们将深入探讨这四个组件以及它们如何协同工作。 1. **Spring框架*...
Spring+SpringMVC+Hibernate框架集成详解
04-12
Spring+SpringMVC+Hibernate 框架集成详解 本文档旨在详细介绍 Spring、SpringMVC 和 Hibernate 框架的集成，旨在帮助开发人员快速了解这三个框架的集成过程。 Spring 框架 Spring 框架是一个 Java 语言的开源...
Maven 搭建SpringMVC+Hibernate项目详解
09-01
在本篇文章中，我们将利用Maven来搭建一个基于SpringMVC和Hibernate的Web应用。首先，我们需要理解SpringMVC是Spring框架的一部分，用于处理HTTP请求，而Hibernate是一个对象关系映射（ORM）框架，简化了数据库操作...
spring+springmvc+hibernate框架搭建项目+jar包
07-17
Spring、SpringMVC和Hibernate是Java开发中常用的三大框架，它们各自负责应用程序的不同层面：Spring作为基础框架，SpringMVC处理Web层业务，而Hibernate则是持久化层的解决方案。本项目是一个整合了这三个框架的...
基于Spring+SpringMVC+Hibernate的图书管理系统
12-28
系统采用技术：Spring+SpringMVC+Hibernate+jQuery+Ajax+面向接口编程。 简介：该图书管理项目实现了三种角色的功能，分别是超级管理员，图书管理员和读者。在系统中，实现了图书管理，统计管理，系统管理和系统监控...
maven+spring mvc+hibernate+dubbo+mysql的demo源码
12-11
maven+spring mvc+hibernate+dubbo+mysql的demo源码,运行前请修改resources/config.properties下的数据配置
dubbo起步搭建Spring+SpringMVC+dubbo的开发环境（2，provider工程构建）
fangxiaoji的专栏
12-10 5764
dubbo起步搭建Spring+SpringMVC+dubbo的开发环境 dubbo服务工程构建
一个你最需要的dubbo入门工程，maven+dubbo+hibernate+redis+mvc+mysql
这个妖姬有点秀
08-23 606
先向一个url进行请求，通过mvn框架映射到相应的controller，消费者会请求提供者暴露在dubbo注册中心（这里用的是zookeeper）上的服务接口，然后远程调用提供方的方法，拿到返回值后返回一个相应的view视图，解析后展示。提供方会通过hiberate对mysql进行查询（前提是redis缓存中没有相应的值），缓存中有值就直接返回。 以下是整体的项目框架。         ...
复习springMVC+dubboConsumer搭建框架
annghi的博客
03-20 1003
1.项目结构 2.配置文件 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://ma
dubbo hibernate懒加载_Dubbo面试问题整理
weixin_35033082的博客
12-20 126
画一画服务注册与发现的流程图Dubbo核心架构图Dubbo 核心的配置有哪些？在 Provider上可以配置的 Consumer 端的属性有哪些？timeout：方法调用超时retries：失败重试次数，默认重试 2 次loadbalance：负载均衡算法，默认随机actives 消费者端最大并发调用限制Dubbo启动时如果依赖的服务不可用会怎样？Dubbo 缺省会在启动时检查依赖的服务是否可用，...
SpringBoot、Dubbo、Redis、Hibernate浅谈
z_623623的博客
12-12 619
一、SpringBoot是spring开源组织下的子项目，是spring组件一站式解决方案，主要是简化了使用spring的难度，节省了繁重的配置，提供了各种启动器，开发者能快速上手。 1.SpringBoot的优点： （1）独立运行（springboot内嵌了各种servlet容器，tomcat、jetty等，不需要打成war包部署到容器中，只需要打成一个可执行的jar包就能独立运行，所以依赖包都在一个jar包内） （2）简化配置（spring-boot-starter-...
Dubbo,ZooKeeper,Redis,FastDFS,ActiveMQ,Keepalived,Nginx,Hudson
weixin_30711917的博客
08-06 173
获取【下载地址】 QQ: 313596790 【免费支持更新】 三大数据库 mysqloraclesqlsever 更专业、更强悍、适合不同用户群体 【新录针对本系统的视频教程，手把手教开发一个模块，高速掌握本系统】 A 集成代码生成器(开发利器)+高速构建表单; QQ：313596790 freemaker模版技术 ，...
dubbo是什么_给他人解释什么是dubbo
weixin_39947396的博客
11-22 148
小小最近开始学习dubbo了，这次进行相关的学习。简介思维导图如下什么是Dubbodubbo 是一款高性能的分布式服务框架，高性能的，透明化的RPC远程调用方案，SOA服务治理方案，与Spring 体系同时并驾崎岖于Java体系生态中。每天为上千个服务提供，使用以及应用。在上方的词语中，出现了，分布式服务，RPC远程调用执行方案，SOA服务治理方案，这里对这几个词语进行依次解释。分布式服务 包含，...
springMVC+Spring+Hibernate框架
最新发布
05-12
SpringMVC+Spring+Hibernate是一种常见的Java Web开发框架组合，也被称为SSH框架。 SpringMVC是基于MVC（Model-View-Controller）模式的Web框架，它提供了一种分离应用程序中不同层的方法，使应用更容易维护和扩展...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值