Spring DataSource JNDI与Tomcat示例

最新推荐文章于 2026-06-20 11:42:29 发布
翻译 最新推荐文章于 2026-06-20 11:42:29 发布 · 838 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
原文链接：https://www.journaldev.com/2597/spring-datasource-jndi-with-tomcat-example
本文提供了一个Spring DataSource JNDI与Tomcat的示例教程，讲解了如何在Spring MVC项目中配置JNDI连接池，以及如何在Tomcat中设置JNDI资源，最终创建一个返回JSON响应的RESTful服务。

Welcome to the Spring DataSource JNDI Tomcat Example Tutorial. Earlier we saw how to implement database operations using Spring JDBC integration. However most of the time enterprise applications are deployed in a servlet container such as Tomcat, JBoss etc.

欢迎使用Spring DataSource JNDI Tomcat示例教程。 前面我们看到了如何使用Spring JDBC集成来实现数据库操作。 但是，大多数时候，企业应用程序都部署在servlet容器中，例如Tomcat，JBoss等。

Spring数据源 (Spring DataSource)

We know that DataSource with JNDI is the preferred way to achieve connection pooling and get benefits of container implementations. Today we will look how we can configure a Spring Web Application to use JNDI connections provided by Tomcat.

我们知道， 带有JNDI的DataSource是实现连接池并从容器实现中受益的首选方法。 今天，我们将研究如何配置Spring Web应用程序以使用Tomcat提供的JNDI连接。

For my example, I will use MySQL database server and create a simple table with some rows. We will create a Spring Rest web service that will return the JSON response with list of all the data in the table.

对于我的示例，我将使用MySQL数据库服务器并创建一个包含一些行的简单表。 我们将创建一个Spring Rest Web服务，该服务将返回JSON响应以及表中所有数据的列表。

数据库设置 (Database Setup)

CREATE TABLE `Employee` (
  `id` int(11) unsigned NOT NULL,
  `name` varchar(20) DEFAULT NULL,
  `role` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

INSERT INTO `Employee` (`id`, `name`, `role`)
VALUES
	(1, 'Pankaj', 'CEO'),
	(2, 'David', 'Manager');
commit;

Spring DataSource MVC项目 (Spring DataSource MVC Project)

Create a Spring MVC Project in the Spring Tool Suite so that our spring application skeleton code is ready. Once we will be done with our implementation, our project structure will look like below image.

在Spring Tool Suite中创建一个Spring MVC项目，以便准备好我们的Spring应用程序框架代码。 完成实施后，我们的项目结构将如下图所示。

Spring JDBC和Jackson依赖关系 (Spring JDBC and Jackson Dependencies)

We will have to add Spring JDBC, Jackson and MySQL Database driver as the dependencies in the pom.xml file. My final pom.xml file looks like below.

我们将不得不在pom.xml文件中添加Spring JDBC，Jackson和MySQL数据库驱动程序作为依赖项。 我的最终pom.xml文件如下所示。 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring</groupId>
	<artifactId>SpringDataSource</artifactId>
	<name>SpringDataSource</name>
	<packaging>war</packaging>
	<version>1.0.0-BUILD-SNAPSHOT</version>
	<properties>
		<java-version>1.6</java-version>
		<org.springframework-version>4.0.2.RELEASE</org.springframework-version>
		<org.aspectj-version>1.7.4</org.aspectj-version>
		<org.slf4j-version>1.7.5</org.slf4j-version>
		<jackson.databind-version>2.2.3</jackson.databind-version>
	</properties>
	<dependencies>
		<!-- Spring JDBC Support -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
		
		<!-- MySQL Driver -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.0.5</version>
		</dependency>
		<!-- Jackson -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>${jackson.databind-version}</version>
		</dependency>
		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${org.springframework-version}</version>
			<exclusions>
				<!-- Exclude Commons Logging in favor of SLF4j -->
				<exclusion>
					<groupId>commons-logging</groupId>
					<artifactId>commons-logging</artifactId>
				 </exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${org.springframework-version}</version>
		</dependency>
				
		<!-- AspectJ -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${org.aspectj-version}</version>
		</dependency>	
		
		<!-- Logging -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${org.slf4j-version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.15</version>
			<exclusions>
				<exclusion>
					<groupId>javax.mail</groupId>
					<artifactId>mail</artifactId>
				</exclusion>
				<exclusion>
					<groupId>javax.jms</groupId>
					<artifactId>jms</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jdmk</groupId>
					<artifactId>jmxtools</artifactId>
				</exclusion>
				<exclusion>
					<groupId>com.sun.jmx</groupId>
					<artifactId>jmxri</artifactId>
				</exclusion>
			</exclusions>
			<scope>runtime</scope>
		</dependency>

		<!-- @Inject -->
		<dependency>
			<groupId>javax.inject</groupId>
			<artifactId>javax.inject</artifactId>
			<version>1</version>
		</dependency>
				
		<!-- Servlet -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>2.5</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet.jsp</groupId>
			<artifactId>jsp-api</artifactId>
			<version>2.1</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>jstl</artifactId>
			<version>1.2</version>
		</dependency>
	
		<!-- Test -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.7</version>
			<scope>test</scope>
		</dependency>        
	</dependencies>
    <build>
        <plugins>
            <plugin>
                <artifactId>maven-eclipse-plugin</artifactId>
                <version>2.9</version>
                <configuration>
                    <additionalProjectnatures>
                        <projectnature>org.springframework.ide.eclipse.core.springnature</projectnature>
                    </additionalProjectnatures>
                    <additionalBuildcommands>
                        <buildcommand>org.springframework.ide.eclipse.core.springbuilder</buildcommand>
                    </additionalBuildcommands>
                    <downloadSources>true</downloadSources>
                    <downloadJavadocs>true</downloadJavadocs>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.5.1</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <compilerArgument>-Xlint:all</compilerArgument>
                    <showWarnings>true</showWarnings>
                    <showDeprecation>true</showDeprecation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>1.2.1</version>
                <configuration>
                    <mainClass>org.test.int1.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

If you are not familiar with Rest in Spring, please read Spring Restful Webservice Example.

如果您不熟悉Spring中的Rest ，请阅读Spring Restful Webservice Example 。

型号类别 (Model Class)

Our Employee bean that is modeled after Employee table, looks like below.

根据Employee表建模的Employee bean如下所示。 

package com.journaldev.spring.jdbc.model;

import java.io.Serializable;

public class Employee implements Serializable{

	private static final long serialVersionUID = -7788619177798333712L;
	
	private int id;
	private String name;
	private String role;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	
	
}

弹簧控制器类 (Spring Controller Class)

Our simple controller class looks like below.

我们简单的控制器类如下所示。 

package com.journaldev.spring.jdbc.controller;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.journaldev.spring.jdbc.model.Employee;

/**
 * Handles requests for the Employee JDBC Service.
 */
@Controller
public class EmployeeController {
	
	private static final Logger logger = LoggerFactory.getLogger(EmployeeController.class);
	
	@Autowired
	@Qualifier("dbDataSource")
	private DataSource dataSource;

	public void setDataSource(DataSource dataSource) {
		this.dataSource = dataSource;
	}

	@RequestMapping(value = "/rest/emps", method = RequestMethod.GET)
	public @ResponseBody List<Employee> getAllEmployees() {
		logger.info("Start getAllEmployees.");
		List<Employee> empList = new ArrayList<Employee>();
		//JDBC Code - Start
		String query = "select id, name, role from Employee";
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);

		List<Map<String,Object>> empRows = jdbcTemplate.queryForList(query);
		
		for(Map<String,Object> empRow : empRows){
			Employee emp = new Employee();
			emp.setId(Integer.parseInt(String.valueOf(empRow.get("id"))));
			emp.setName(String.valueOf(empRow.get("name")));
			emp.setRole(String.valueOf(empRow.get("role")));
			empList.add(emp);
		}
		
		return empList;
	}

}

Important Points about the Controller class are:

关于Controller类的要点是：

  • DataSource will be wired by Spring Bean configuration with name dbDataSource.

    数据源将通过名称为dbDataSource的Spring Bean配置进行连接。
  • We are using JdbcTemplate to avoid common errors such as resource leak and remove JDBC boiler plate code.

    我们正在使用JdbcTemplate来避免常见错误，例如资源泄漏，并删除JDBC样板代码。
  • URI to retrieve the list of Employee will be https://{host}:{port}/SpringDataSource/rest/emps

    检索Employee列表的URI是https：// {host}：{port} / SpringDataSource / rest / emps
  • We are using @ResponseBody to send the list of Employee objects as response, Spring will take care of converting it to JSON.

    我们使用@ResponseBody发送Employee对象的列表作为响应，Spring将负责将其转换为JSON。

Spring Bean配置 (Spring Bean Configuration)

There are two ways through which we can JNDI lookup and wire it to the Controller DataSource, my spring bean configuration file contains both of them but one of them is commented. You can switch between these and the response will be the same.

我们可以通过两种方法进行JNDI查找并将其连接到Controller DataSource，我的spring bean配置文件包含这两种方法，但是其中一种被注释了。 您可以在这些之间切换，响应将相同。

  1. Using jee namespace tag to perform the JNDI lookup and configure it as a Spring Bean. We also need to include jee namespace and schema definition in this case.

    使用jee名称空间标签执行JNDI查找并将其配置为Spring Bean。 在这种情况下，我们还需要包括jee命名空间和架构定义。
  2. Creating a bean of type org.springframework.jndi.JndiObjectFactoryBean by passing the JNDI context name. jndiName is a required parameter for this configuration.

    通过传递JNDI上下文名称，创建类型为org.springframework.jndi.JndiObjectFactoryBean的bean。 jndiName是此配置的必需参数。

My spring bean configuration file looks like below.

我的spring bean配置文件如下所示。 

<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="https://www.springframework.org/schema/mvc"
	xmlns:jee="https://www.springframework.org/schema/jee"
	xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance" xmlns:beans="https://www.springframework.org/schema/beans"
	xmlns:context="https://www.springframework.org/schema/context"
	xsi:schemaLocation="https://www.springframework.org/schema/jee https://www.springframework.org/schema/jee/spring-jee.xsd
		https://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd
		https://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		https://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">

	<!-- DispatcherServlet Context: defines this servlet's request-processing 
		infrastructure -->

	<!-- Enables the Spring MVC @Controller programming model -->
	<annotation-driven />

	<!-- Handles HTTP GET requests for /resources/** by efficiently serving 
		up static resources in the ${webappRoot}/resources directory -->
	<resources mapping="/resources/**" location="/resources/" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources 
		in the /WEB-INF/views directory -->
	<beans:bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<beans:property name="prefix" value="/WEB-INF/views/" />
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>

	<!-- Configure to plugin JSON as request and response in method handler -->
	<beans:bean
		class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
		<beans:property name="messageConverters">
			<beans:list>
				<beans:ref bean="jsonMessageConverter" />
			</beans:list>
		</beans:property>
	</beans:bean>

	<!-- Configure bean to convert JSON to POJO and vice versa -->
	<beans:bean id="jsonMessageConverter"
		class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
	</beans:bean>
	
	<!-- Create DataSource Bean -->
	 
	<beans:bean id="dbDataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
    	<beans:property name="jndiName" value="java:comp/env/jdbc/MyLocalDB"/>
	</beans:bean>
	 
	 <!-- using JEE namespace for lookup -->
	 <!-- 
	 <jee:jndi-lookup id="dbDataSource" jndi-name="jdbc/MyLocalDB"
   			expected-type="javax.sql.DataSource" />
	  -->
	  
	<context:component-scan base-package="com.journaldev.spring.jdbc.controller" />

</beans:beans>

Tomcat数据源JNDI配置 (Tomcat DataSource JNDI Configuration)

Now that we are done with our project, the final part is to do the JNDI configuration in Tomcat container to create the JNDI resource.

现在我们完成了项目，最后一部分是在Tomcat容器中进行JNDI配置，以创建JNDI资源。 

<Resource name="jdbc/TestDB" 
      global="jdbc/TestDB" 
      auth="Container" 
      type="javax.sql.DataSource" 
      driverClassName="com.mysql.jdbc.Driver" 
      url="jdbc:mysql://localhost:3306/TestDB" 
      username="pankaj" 
      password="pankaj123" 
      
      maxActive="100" 
      maxIdle="20" 
      minIdle="5" 
      maxWait="10000"/>

Add above configuration in the GlobalNamingResources section of the server.xml file.

在server.xml文件的GlobalNamingResources部分中添加以上配置。 

<ResourceLink name="jdbc/MyLocalDB"
                	global="jdbc/TestDB"
                    auth="Container"
                    type="javax.sql.DataSource" />

We also need to create the Resource Link to use the JNDI configuration in our application, best way to add it in the server context.xml file.

我们还需要创建资源链接以在我们的应用程序中使用JNDI配置，这是将其添加到服务器context.xml文件中的最佳方法。

Notice that ResourceLink name should be matching with the JNDI context name we are using in our application. Also make sure MySQL jar is present in the tomcat lib directory, otherwise tomcat will not be able to create the MySQL database connection pool.

注意，ResourceLink名称应与我们在应用程序中使用的JNDI上下文名称匹配。 还要确保tomcat lib目录中存在MySQL jar，否则tomcat将无法创建MySQL数据库连接池。

运行Spring DataSource JNDI示例项目 (Running the Spring DataSource JNDI Sample Project)

Our project and server configuration is done and we are ready to test it. Export the project as WAR file and place it in the tomcat deployment directory.

我们的项目和服务器配置已完成，我们准备对其进行测试。 将项目导出为WAR文件，并将其放置在tomcat部署目录中。

The JSON response for the Rest call is shown in the below image.

下图显示了Rest调用的JSON响应。

That’s all for the Spring integration with servlet container JNDI context, download the sample project from the below link and play around with it to learn more.

这就是与Servlet容器JNDI上下文进行Spring集成的全部内容，请从下面的链接下载示例项目，并进行操作以了解更多信息。

翻译自: https://www.journaldev.com/2597/spring-datasource-jndi-with-tomcat-example

标签
#数据库 #spring #java #mysql #spring boot
cunchi4221
关注
Tomcat中JNDI DataSource配置及使用
甘蓝的专栏
02-01 4879
下面的例子是在Tomcat7中配置JNDI DataSource，并把这个JNDI注册为Spring的Bean。
Nishang框架解析：PowerShell攻击技术与防御实践
tang_zongyun的博客
06-16 456
PowerShell作为Windows系统管理和自动化的核心脚本环境，其强大的功能不仅被管理员广泛使用，也成为攻击者进行渗透测试和红队行动的重要工具。通过内存执行、编码混淆等技术原理，攻击者能够绕过传统基于文件特征的防御机制，实现无文件攻击和隐蔽命令控制。这种技术价值在于能够无缝融入现代Windows环境，从Windows 7到最新的Windows Server版本都能有效运作。在应用场景上，它覆盖了信息收集、权限提升、横向移动、持久化等完整攻击链环节，特别在企业内网渗透和红蓝对抗演练中具有重要实践意义。N
Spring DataSource JNDI - Tomcat JNDI 配置示例
YunWisdom
03-16 2257
Spring DataSource JNDI 的 Tomcat配置示例 欢迎使用Spring DataSource JNDI Tomcat示例教程。之前我们看到了如何使用Spring JDBC集成实现数据库操作。但是，大多数情况下企业应用程序都部署在一个servlet容器中，例如Tomcat，JBoss等。 目录[隐藏] 1Spring DataSource ...
在spring用jndi得到tomcat中的datasource的问题
sm
12-09 261
今天想把项目中配置在spring中的数据源移到tomcat中来配置，遇见了一些问题，请各位指教，小弟感谢了。 目的：从spring中得到tomcat中配置的datasource。 我的做法： 在tomcat的context.xml文件中GlobalNamingResources标签中加入如下代码： &lt;Resource          name="dataSource"         ...
java datasource 配置_Spring中配置DataSource数据源的3种选择
weixin_28808145的博客
03-04 1223
Spring中配置DataSource数据源的几种选择在Spring框架中有如下3种获得DataSource对象的方法:从JNDI获得DataSource.从第三方的连接池获得DataSource.使用DriverManagerDataSource获得DataSource.一、从JNDI获得DataSourceSpringJNDI数据源配置信息： java:comp/env/jc...
spring jndi mysql_经过JNDI从服务器容器中获取资源_Spring JNDI+Mysql+Tomcat_mysql
weixin_39526706的博客
01-21 137
通过JNDI从服务器容器中获取资源_Spring JNDI+mysql+Tomcat通过JNDI从服务器容器中获取DataSource资源 (由容器管理，不要关闭它，容器自己会处理)上一篇我们使用的是dbcp，这里使用JNDI：使用JNDI连接数据：在Spring注释使用： java:comp/env/jdbc/joba 一、添加数据库驱动文件通过数据源访问数据库，由于数据...
JNDI（datasource）在tomcat，JBOSS下的spring+quartz配置
weixin_34355715的博客
07-14 356
由于项目中多个小应用（类似插件）需要使用数据库连接池，不能为每一个应用中配置连接池。故采用JNDI的模式进行配置。 我们使用的web服务器有tomcat和jboss两种。分别介绍其在这两种服务器下并且在两种应用模式spring+hebernat与quartz下的配置。 tomcat下： 1）在tomcat 6.0下配置JNDI及在Spring中的...
Spring配置JNDI及通过JNDI获取DataSource
MR.L'S BLOG
03-07 2448
1、SpringJNDI数据源配置信息：java:comp/env/jcptDataSourceJNDI  红色部分是tomcat或者其他应用服务器配置的JNDI.2、关于JNDI的配置(tomcat)：  修改tomcat目录conf/context.xml文件：      maxActive="100" maxIdle="30" maxWait="10000"   username="tysp"
java spring jndi配置_Spring MVC 使用 JNDI 配置的DataSource
weixin_42168830的博客
02-24 471
稍微看了下，Spring 中JNDI 的使用，弄了个小例子。有很多不完备的地方，以后慢慢看，再改吧。 技术使用Spring MVCJDBC TemplateMavenJNDI 一些配置Maven POM 配置spring-context、spring-webmvc、spring-orm、spring-jdbc、mysql-connector-java等创建数据库createdatabaseus...
Jndi结合spring bean配置
abckingaa的博客
02-13 824
本文介绍,使用spring mvc 如何配置jndi的dataSource. 1. 首先在tomcat下配置jndi相关信息. <Context docBase="D:\workspace\.metadata\.plugins\org.eclipse.wst.server.core\tmp0\wtpwebapps\xxx" path="/xxx" reloadable="true" source="org.eclipse.jst.jee.server:xxx"> ...
tomcat下的JNDI配置
爱吃鱼油
11-07 666
jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。
Spring获得DataSource
330553352的专栏
11-30 724
一、从JNDI获得DataSource 1.1、Spring JNDI数据源配置信息 <bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"> <property name="jndiName"> <value>java:comp/env/jc...
Spring配置JNDI和通过JNDI获取DataSource
qq_38056704的博客
08-03 6581
JDNI:访问数据库有四步，加载驱动，获取连接，操作数据库，关闭连接；其中只有操作数据库是动态的，其他都是固定的，jdni作用就是就是配置连接池和减少重复代码。 一、SpringJNDI数据源配置信息 1 &lt;bean id="dataSource" class="org.springframework.jndi.JndiObjectFactoryBean"&gt; 2 &lt;prop...
Spring整合Tomcat JNDI数据源实战指南
最新发布
dixi7825的博客
06-20 406
JNDI（Java Naming and Directory Interface）是Java平台标准的命名与目录服务接口，其核心原理是通过逻辑名称解耦资源定位与实现细节，实现容器级资源统一治理。在企业级Java Web应用中，JNDI为DataSource提供了跨应用、可审计、环境无关的注入机制，显著提升安全合规性与运维可控性。尤其在金融、政务等强监管场景下，结合Tomcat容器管理的数据源，能有效规避密码硬编码、连接参数分散、多环境配置不一致等典型工程痛点。本文聚焦Spring框架如何精准对接Tomcat
spring boot配置Jndi
abckingaa的博客
02-13 2604
#这里的name很重要，在tomcat里需要指定相同名称的resource spring.datasource.jndi-name=java:comp/env/jdbc/myDs spring.datasource.expected-type = javax.sql.DataSource spring.datasource.driver-class-name = com.mysql.jdbc.Driver 参考: https://www.cnblogs.com/cnsyear/p/1291...
Spring框架中TOMCAT 的JNDI配置和使用
安迪的专栏
02-13 300
在Spring框架下，使用Tomcat服务器也想使用JNDI的情况。首先必须安装Tomcat-Admin，这个网上多的是。安装之后就可以登陆http://localhost:8080/admin 界面后，选择Resource ， DataSources，下拉菜单，Create New DataSource。进行JNDI的建立操作。具体如下：       JNDI名称：jdbc/mssql    ...
DataSource和JNDI
不忘初心
02-26 679
JDBC API 为连接池提供了一个客户端和一个服务器端的接口。 客户端接口是 javax.sql.DataSource， 通常就是应用代码用来请求一个缓冲了的数据库连接的东西。 服务器接口是javax.sql.ConnectionPoolDataSource， 通常是大多数应用服务器和 MysqlSQL JDBC 驱动打交道的接口。 初始化连接池DataSource的代码： My...
java tomcat jndi,Tomcat中使用JNDI时需要注意的地方
weixin_35719402的博客
03-20 289
在tomcat中数据库连接使用JNDI时，在spring配置文件中的名字前需要加上一个前缀：java:comp/env/，否则系统启动时会报Name jdbc is not bound in this Context。比如在tomcat的Context.xml中配的JNDI如下auth="Container"type="javax.sql.DataSource"username="user"pas...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值