Groovy对Spring动态语言的支持

最新推荐文章于 2024-03-22 11:37:55 发布
最新推荐文章于 2024-03-22 11:37:55 发布
阅读量290 收藏
点赞数
文章标签： 编程语言 java spring spring boot maven

Groovy是一种在JVM上运行的动态且面向对象的编程语言。 它使用Java之类的语法，可以嵌入Java并编译为字节码。 可以从Groovy调用Java代码，反之亦然。 Groovy的一些功能包括元和函数编程，动态类型化（使用def关键字），闭包，GroovyBeans，Groovlets，与Bean脚本框架（BSF）集成，泛型，注释和集合支持。

本文通过以下方式介绍了对Groovy的基本Spring Dynamic Language支持：

  1. 通过使用Java语法和Spring 构造型，
  2. 通过使用Groovy语法和Spring 构造型，
  3. 通过使用内联脚本功能 ，
  4. 通过使用Spring Groovy语言支持（lang：groovy） 。
二手技术：
  • JDK 1.7.0_09
  • Spring3.2.0
  • Groovy 2.0.4
  • Maven的3.0.4

步骤1：建立已完成的专案

创建一个Maven项目，如下所示。 （可以使用Maven或IDE插件来创建它）。

步骤2：图书馆

首先，将依赖项添加到Maven的pom.xml中。 

<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<spring.version>3.2.0.RELEASE</spring.version>
	</properties>	

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

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

	<dependency>
		<groupId>org.codehaus.groovy</groupId>
		<artifactId>groovy-all</artifactId>
		<version>2.0.4</version>
	</dependency>

maven-compiler-plugin（Maven插件）用于使用JDK 1.7编译项目 

<plugin>
		<artifactId>maven-compiler-plugin</artifactId>
		<version>2.3.2</version>
		<configuration>
			<compilerId>groovy-eclipse-compiler</compilerId>
			<verbose>true</verbose>
			<source>1.7</source>
			<target>1.7</target>
			<encoding>${project.build.sourceEncoding}</encoding>
		</configuration>
		<dependencies>
			<dependency>
				<groupId>org.codehaus.groovy</groupId>
				<artifactId>groovy-eclipse-compiler</artifactId>
				<version>2.6.0-01</version>
			</dependency>
		</dependencies>
	</plugin>

maven-shade-plugin（Maven插件）可用于创建runnable-jar 

<plugin>
		<groupId>org.apache.maven.plugins</groupId>
		<artifactId>maven-shade-plugin</artifactId>
		<version>2.0</version>

		<executions>
			<execution>
				<phase>package</phase>
				<goals>
					<goal>shade</goal>
				</goals>
				<configuration>
					<createDependencyReducedPom>false</createDependencyReducedPom>
					<configuration>
						<source>1.7</source>
						<target>1.7</target>
					</configuration>
					<transformers>
						<transformer
							implementation='org.apache.maven.plugins.shade.resource.ManifestResourceTransformer'>
							<mainClass>com.onlinetechvision.exe.Application</mainClass>
						</transformer>
						<transformer
							implementation='org.apache.maven.plugins.shade.resource.AppendingTransformer'>
							<resource>META-INF/spring.handlers</resource>
						</transformer>
						<transformer
							implementation='org.apache.maven.plugins.shade.resource.AppendingTransformer'>
							<resource>META-INF/spring.schemas</resource>
						</transformer>
					</transformers>
				</configuration>
			</execution>
		</executions>
	</plugin>

步骤3：建立员工班级

员工 Bean已创建。 

package com.onlinetechvision.employee;

/**
 * Employee Bean
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
public class Employee {

	private String id;
	private String name;
	private String surname;

	public Employee(String id, String name, String surname) {
		this.id = id;
		this.name = name;
		this.surname = surname;
	}

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSurname() {
		return surname;
	}

	public void setSurname(String surname) {
		this.surname = surname;
	}	

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		result = prime * result + ((surname == null) ? 0 : surname.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Employee other = (Employee) obj;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		if (surname == null) {
			if (other.surname != null)
				return false;
		} else if (!surname.equals(other.surname))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return 'Employee [id=' + id
				            + ', name=' + name
							+ ', surname=' + surname + ']';
	}	

}
方法1：使用JAVA SYNTAX

步骤4：建立IGroovyEmployeeCacheService接口

创建IGroovyEmployeeCacheService接口以公开Groovy缓存功能。 

package com.onlinetechvision.groovy.srv

import com.onlinetechvision.employee.Employee

/**
 * IGroovyEmployeeCacheService Interface exposes cache functionality.
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
interface IGroovyEmployeeCacheService {

	/**
	 * Adds employee entry to cache
	 *
	 * @param Employee employee
	 *
	 */
	void addToEmployeeCache(Employee employee);

	/**
	 * Gets employee entry from cache
	 *
	 * @param String id
	 * @return Employee employee
	 */
	Employee getFromEmployeeCache(String id);

	/**
	 * Removes employee entry from cache
	 *
	 * @param Employee employee
	 *
	 */
	void removeFromEmployeeCache(Employee employee);

}

步骤5：创建GroovyEmployeeCacheService IMPL

GroovyEmployeeCacheService类是通过实现IGroovyEmployeeCacheService接口创建的。 

package com.onlinetechvision.groovy.srv

import com.onlinetechvision.employee.Employee;
import org.springframework.stereotype.Service;

/**
 * GroovyEmployeeCacheService Class is implementation of IGroovyEmployeeCacheService Interface.
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
@Service
class GroovyEmployeeCacheService implements IGroovyEmployeeCacheService  {

	private Map<String, Employee> cache = new HashMap();

	/**
	 * Adds employee entry to cache
	 *
	 * @param Employee employee
	 *
	 */
	public void addToEmployeeCache(Employee employee) {
		getCache().put(employee.getId(), employee);
		println print(employee, 'added to cache...');
	}

	/**
	 * Gets employee entry from cache
	 *
	 * @param String id
	 * @return Employee employee
	 */
	public Employee getFromEmployeeCache(String id) {
		Employee employee = getCache().get(id);
		println print(employee, 'gotten from cache...');
		return employee;
	}

	/**
	 * Removes employee entry from cache
	 *
	 * @param Employee employee
	 *
	 */
	public void removeFromEmployeeCache(Employee employee) {
		getCache().remove(employee.getId());
		println print(employee, 'removed from cache...');
		println 'Groovy Cache Entries :' + getCache();
	}

	public Map<String, Employee> getCache() {
		return cache;
	}

	public void setCache(Map<String, Employee> map) {
		cache = map;
	}

	/**
	 * Prints operation information
	 *
	 * @param Employee employee
	 * @param String description
	 *
	 */
	private String print(Employee employee, String desc) {
		StringBuilder strBldr = new StringBuilder();
		strBldr.append(employee)
		strBldr.append(' ');
		strBldr.append(desc);

		return strBldr.toString();
	}
}

步骤6：建立IEmployeeService接口

IUserService接口是为Spring服务层创建的，显示了如何集成Spring和Groovy服务层。 

package com.onlinetechvision.spring.srv;

import com.onlinetechvision.employee.Employee;

/**
 * IEmployeeService Interface is created to represent Spring Service layer.
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
public interface IEmployeeService {

	/**
	 * Adds Employee entry to cache
	 *
	 * @param Employee employee
	 *
	 */
	void addToGroovyEmployeeCache(Employee employee);

	/**
	 * Gets Employee entry from cache
	 *
	 * @param String id
	 * @return Employee employee
	 */
	Employee getFromGroovyEmployeeCache(String id);

	/**
	 * Removes Employee entry from cache
	 *
	 * @param Employee employee
	 *
	 */
	void removeFromGroovyEmployeeCache(Employee employee);	

}

步骤7：创建EmployeeService IMPL

EmployeeService类是通过实现IUserService接口创建的。 

package com.onlinetechvision.spring.srv;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.onlinetechvision.employee.Employee;
import com.onlinetechvision.groovy.srv.IGroovyEmployeeCacheService;

/**
 * EmployeeService Class is implementation of IEmployeeService interface.
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
@Service
public class EmployeeService implements IEmployeeService {

	@Autowired
	private IGroovyEmployeeCacheService groovyEmployeeCacheService ;

	/**
	 * Adds Employee entry to cache
	 *
	 * @param Employee employee
	 *
	 */
	public void addToGroovyEmployeeCache(Employee employee) {
		getGroovyEmployeeCacheService().addToEmployeeCache(employee);
	}

	/**
	 * Gets Employee entry from cache
	 *
	 * @param String id
	 * @return Employee employee
	 */
	public Employee getFromGroovyEmployeeCache(String id) {
		return getGroovyEmployeeCacheService().getFromEmployeeCache(id);
	}	

	/**
	 * Removes Employee entry from cache
	 *
	 * @param Employee employee
	 *
	 */
	public void removeFromGroovyEmployeeCache(Employee employee) {
		getGroovyEmployeeCacheService().removeFromEmployeeCache(employee);
	}

	public IGroovyEmployeeCacheService getGroovyEmployeeCacheService() {
		return groovyEmployeeCacheService;
	}

	public void setGroovyEmployeeCacheService(IGroovyEmployeeCacheService groovyEmployeeCacheService) {
		this.groovyEmployeeCacheService = groovyEmployeeCacheService;
	}	

}

步骤8：创建applicationContext.xml

Spring配置文件applicationContext.xml已创建。 

<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'
	xsi:schemaLocation='http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd'>

	<context:component-scan base-package='com.onlinetechvision.spring.srv, com.onlinetechvision.groovy.srv'/>

</beans>

步骤9：创建应用程序类

创建应用程序类以运行应用程序。 

package com.onlinetechvision.exe;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.onlinetechvision.spring.srv.EmployeeService;
import com.onlinetechvision.spring.srv.IEmployeeService;
import com.onlinetechvision.employee.Employee;

/**
 * Application Class starts the application
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
public class Application
{
	/**
     * Starts the application
     *
     * @param  String[] args
     *
     */
	public static void main(String[] args) {
		ApplicationContext context = new ClassPathXmlApplicationContext('applicationContext.xml');

		IEmployeeService employeeService = (IEmployeeService) context.getBean(EmployeeService.class);

		Employee firstEmployee = new Employee('1', 'Jake', 'Gyllenhaal');
		Employee secondEmployee = new Employee('2', 'Woody', 'Harrelson');

		employeeService.addToGroovyEmployeeCache(firstEmployee);
		employeeService.getFromGroovyEmployeeCache(firstEmployee.getId());
		employeeService.removeFromGroovyEmployeeCache(firstEmployee);

		employeeService.addToGroovyEmployeeCache(secondEmployee);
		employeeService.getFromGroovyEmployeeCache(secondEmployee.getId());
	}

}

步骤10：建立专案

生成OTV_Spring_Groovy项目后，将创建OTV_Spring_Groovy-0.0.1-SNAPSHOT.jar 。

步骤11：运行项目

运行创建的OTV_Spring_Groovy-0.0.1-SNAPSHOT.jar文件后，输出日志显示为followingwing： 

Employee [id=1, name=Jake, surname=Gyllenhaal] added to cache...
Employee [id=1, name=Jake, surname=Gyllenhaal] gotten from cache...
Employee [id=1, name=Jake, surname=Gyllenhaal] removed from cache...
Groovy Cache Entries :[:]

Employee [id=2, name=Woody, surname=Harrelson] added to cache...
Employee [id=2, name=Woody, surname=Harrelson] gotten from cache...

到目前为止，已经解释了第一种方法。 让我们看看其他方式：

方法2：使用Groovy语法

IGroovyEmployeeCacheService接口和GroovyEmployeeCacheService Impl也可以使用Groovy语法进行如下设计：

步骤12.1：创建IGroovyEmployeeCacheService接口

IGroovyEmployeeCacheService接口是使用Groovy语法创建的。 

package com.onlinetechvision.groovy.srv

import com.onlinetechvision.employee.Employee

/**
 * IGroovyEmployeeCacheService Interface exposes cache functionality.
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
interface IGroovyEmployeeCacheService {

	/**
	 * Adds employee entry to cache
	 *
	 * @param Employee employee
	 *
	 */
	def addToEmployeeCache(Employee employee);

	/**
	 * Gets employee entry from cache
	 *
	 * @param String id
	 * @return Employee employee
	 */
	def getFromEmployeeCache(String id);

	/**
	 * Removes employee entry from cache
	 *
	 * @param Employee employee
	 *
	 */
	def removeFromEmployeeCache(Employee employee);

}

步骤12.2：创建GroovyEmployeeCacheService IMPL

GroovyEmployeeCacheService类是使用Groovy语法创建的。 

package com.onlinetechvision.groovy.srv

import com.onlinetechvision.employee.Employee;
import org.springframework.stereotype.Service;

/**
 * GroovyEmployeeCacheService Class is implementation of IGroovyEmployeeCacheService Interface.
 *
 * @author onlinetechvision.com
 * @since 24 Dec 2012
 * @version 1.0.0
 *
 */
@Service
class GroovyEmployeeCacheService implements IGroovyEmployeeCacheService  {

	def cache = new HashMap();

	/**
	 * Adds employee entry to cache
	 *
	 * @param Employee employee
	 *
	 */
	def addToEmployeeCache(Employee employee) {
		getCache().put(employee.getId(), employee);
		println print(employee, 'added to cache...');
	}

	/**
	 * Gets employee entry from cache
	 *
	 * @param String id
	 * @return Employee employee
	 */
	def getFromEmployeeCache(String id) {
		Employee employee = getCache().get(id);
		println print(employee, 'gotten from cache...');
		return employee;
	}

	/**
	 * Removes employee entry from cache
	 *
	 * @param Employee employee
	 *
	 */
	def removeFromEmployeeCache(Employee employee) {
		getCache().remove(employee.getId());
		println print(employee, 'removed from cache...');
		println 'Groovy Cache Entries :' + getCache();
	}

	def getCache() {
		return cache;
	}

	def setCache(Map<String, Employee> map) {
		cache = map;
	}

	/**
	 * Prints operation information
	 *
	 * @param Employee employee
	 * @param String description
	 *
	 */
	def print(Employee employee, String desc) {
		StringBuilder strBldr = new StringBuilder();
		strBldr.append(employee)
		strBldr.append(' ');
		strBldr.append(desc);
	}
}
方法3：使用内联脚本功能

GroovyEmployeeCacheService Impl也可以通过使用以下内联脚本功能进行定义：

步骤13.1：通过applicationContext.xml定义GroovyEmployeeCacheService IMPL

GroovyEmployeeCacheService Impl类可以在applicationContext.xml中定义。 

<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:lang='http://www.springframework.org/schema/lang'
	xsi:schemaLocation='http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/lang

http://www.springframework.org/schema/lang/spring-lang-3.0.xsd'>

	<context:component-scan base-package='com.onlinetechvision.spring.srv'/>

	<lang:groovy id='groovyEmployeeCacheService'>
	    <lang:inline-script>
			package com.onlinetechvision.groovy.srv

			import com.onlinetechvision.employee.Employee;
			import org.springframework.stereotype.Service;

			class GroovyEmployeeCacheService implements IGroovyEmployeeCacheService {

				def cache = new HashMap();

				def addToEmployeeCache(Employee employee) {
					getCache().put(employee.getId(), employee);
					println print(employee, 'added to cache...');
				}

				def getFromEmployeeCache(String id) {
					Employee employee = getCache().get(id);
					println print(employee, 'gotten from cache...');
					return employee;
				}

				def removeFromEmployeeCache(Employee employee) {
					getCache().remove(employee.getId());
					println print(employee, 'removed from cache...');
					println 'Groovy Cache Entities :' + getCache();
				}

				def getCache() {
					return cache;
				}

				def setCache(Map map) {
					cache = map;
				}

				def print(Employee employee, String desc) {
					StringBuilder strBldr = new StringBuilder();
					strBldr.append(employee)
					strBldr.append(' ');
					strBldr.append(desc);
				}
			}
	    </lang:inline-script>
	</lang:groovy>

</beans>
方法4：使用Spring Groovy语言支持

还可以将GroovyEmployeeCacheService Impl定义为Spring应用程序上下文，而无需使用以下构造型（@Service）：

步骤14.1：通过applicationContext.xml定义GroovyEmployeeCacheService IMPL

GroovyEmployeeCacheService Impl类可以在applicationContext.xml中定义。 

<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:lang='http://www.springframework.org/schema/lang'
	xsi:schemaLocation='http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context-3.0.xsd

http://www.springframework.org/schema/lang

http://www.springframework.org/schema/lang/spring-lang-3.0.xsd'>

	<context:component-scan base-package='com.onlinetechvision.spring.srv'/>

	<lang:groovy id='groovyEmployeeCacheService' script-source='classpath:com/onlinetechvision/groovy/srv/GroovyEmployeeCacheService.groovy'/>

</beans>

步骤15：下载

https://github.com/erenavsarogullari/OTV_Spring_Groovy

资源：

Groovy用户指南
Spring动态语言支持

参考： Online Technology Vision博客上来自我们JCG合作伙伴 Eren Avsarogullari的Groovy提供的Spring动态语言支持 。

翻译自: https://www.javacodegeeks.com/2013/01/spring-dynamic-language-support-with-groovy.html

danpie3295
关注
Groovy在Spring中的简单使用
08-11
Groovy在Spring中的简单使用，欢迎下载！
在Spring+Hibernate框架下，用动态语言写业务类
花钱的年华
06-13 1万+
    如果羡慕Ruby On Rails可以用动态语言来编码，但又舍不得Spring、Hibernate这些Javaer深以为傲的框架，那么有一种折中的方案：    仍然使用Spring+Hibernate框架，而用Groovy/Jython/JRuby来编写Controller类、Service类、DAO类，并把它们编译成普通的Java Class文件来使用。    BuggyBean的blo
Spring4.0支持Groovy配置
iteye_13605的博客
07-24 285
介绍 前一段时间观注了一下Spring4.0的一些特性，其中就有对Groovy配置的支持。由于暂时还没有非常深入的研究，所以举个小例子来说明一下如何支持Groovy配置。 package shuai.study.spring.bean; public class Gasoline { private int capacity = 0; public Gasoline(int...
java 动态语言,使用Java配置中的Spring动态语言支持
weixin_31109967的博客
02-22 171
I'd like to use Dynamic Languages Support of Spring Framework.In XML I'd just use the lang namespace, but I'd like to use Java configuration (i.e. @Configuration classes) only.I can imagine that I can...
spring groovy
GranteZhou的专栏
09-21 152
在spring和groovy整合中，如何将groovy脚本配置到spring 的xml中： 1、参考内容： http://static.springsource.org/spring/docs/2.0.x/reference/dynamic-language.html 2、本地实例： &lt;?xml version="1.0" encoding="GBK"?&gt; &lt;beans...
Groovy 使 Spring 更出色，第 1 部分: 集成的基础知识
04-21 315
 Spring 2.0 支持将动态语言集成到基于 Spring 的应用程序中。Spring 开箱即用地支持 Groovy、JRuby 和 BeanShell。以 Groovy、JRuby 或任何受支持的语言（当然包括 Java™ 语言）编写的应用程序部分可以无缝地集成到 Spring 应用程序中。应用程序其他部分的代码不需要知道或关心单个 Spring bean 的实现语言。Spring
spring动态语言国际化
hai19850514的博客
09-30 186
一、动态语言国际化配置使用Spring的MVC，并且配置中有配置文件，messageResource_en_US.properties、messageResource_zh_CN.propertiesxml 代码&lt;!-- 资源文件绑定器 --&gt;           &lt;bean id="messageSource" class="org.springframework.cont...
使用Spring Introducation 让Java类实现动态语言特性
我的世界我的梦
10-10 1282
当我们没有一个实现类源代码以致不能为实现类增加新的方法时，我们在java语言中往往是无法实现的，但动态语言比（如JS），对动态对象增加可操作的方法是很容易得，我们借助Spring的Introduction这个特殊的advise,同样可以实现动态语言的这个特性 原始的业务接口及实现 package Introduction;public interface ISome ...{ 
Groovy与Spring Boot整合入门教程
最新发布
里查叔叔
03-22 1553
这样可以确保脚本的来源是可信的，并且可以避免潜在的安全风险。对于更复杂的用例，你可能需要考虑使用更高级的Groovy集成方法，如使用Groovy的AST转换或编写自定义的Groovy编译器插件等。在开始学习这些方法之前，建议先熟悉Groovy的基本语法和特性，并通过简单的示例和项目实践来逐步提高自己的技能水平。Groovy是一种基于JVM的动态编程语言，具有简洁的语法和强大的特性，如闭包、扩展方法和动态类型等。将Groovy与Spring Boot整合，可以在项目中利用Groovy的灵活性，提高开发效率。
Java调用groovy及groovy中如何使用springBean
很多时候犯错都是在不知情的情况下发生的
11-28 2033
一、概述 Groovy is a multi-faceted language for the Java platform. Apache Groovy是一种强大的、可选的类型化和动态语言，具有静态类型和静态编译功能，用于Java平台，目的在于通过简洁、熟悉和易于学习的语法提高开发人员的工作效率。它可以与任何Java程序顺利集成，并立即向您的应用程序提供强大的功能，包括脚本编写功能、特定于域的语言编写、运行时和编译时元编程以及函数式编程。 Groovy是基于java虚拟机的，执行文件可以是简单的脚本片
spring + groovy 实现动态代码注入执行
weixin_30823001的博客
09-21 195
https://blog.csdn.net/weixin_34318326/article/details/89585186 转载于:https://www.cnblogs.com/diyunpeng/p/11561230.html
Spring使用Groovy动态脚本化编程
布奇小米
11-03 1496
总结一套groovy脚本语言与spring容器完美结合的动态执行能力 1.groovy脚本 groovy 是JVM脚本语言，可以在JVM环境中编译运行，基于这个特性，我们只需要在项目中封装好了对脚本的编译逻辑-运行接口，那么在JVM中动态运行groovy脚本就顺利成章了，可喜的是，groovy 提供了GroovyShell 和 Script 类专门提供这样的逻辑，所以代码写起来就简单的多了 /** * 动态执行groovy脚本代码 * @param scriptStr * @return */ pu
利用SPRING管理热加载的GROOVY对象！
程序猿DD
09-30 3872
作者：paleXu的技术博客来源：https://palexu.github.io/posts/spring-dynamic-load-groovy-bean?hmsr=...
java groovy集成_Spring中集成Groovy的四种方式(小结)
weixin_39762478的博客
02-16 706
groovy是一种动态脚本语言，适用于一些可变、和规则配置性的需求，目前Spring提供ScriptSource接口，支持两种类型，一种是ResourceScriptSource，另一种是 StaticScriptSource，但是有的场景我们需要把groovy代码放进DB中，所以我们需要扩展这个。ResourceScriptSource：在 resources 下面写groovy类StaticS...
spring + groovy 很强大
热门推荐
qq362228416的专栏
04-16 1万+
groovy是一门基于JVM的动态语言，跟spring结合更显强大，废话不多说，直接上例子 1、定义java接口 Foo.java package groovy; public interface Foo { void execute(); } 2、定义Groovy实现类 FooImpl.groovy package groovy import groovy.Foo
Spring4--Spring SpEL
DeepingC
11-14 761
背景 Spring动态表达式语言（简称SpEL）。是一种动态语言。 1.JVM动态语言 java是强类型的静态语言，所有代码在运行之前都必须进行严格的类型检查并编译成JVM字节码，这个特性就决定了 java在语言层面无法直接进行表达式语句的动态解析。而动态语言可以在程序运行时改变程序结构或变量类型。为了 简化java使用动态语言的难度，java6.0开始提供对JSR-223规范的全面支持...
Spring与Groovy的强强联合：动态语言集成解析
"Groovy使Spring更出色，集成的基础知识" Spring框架的2.0版本引入了一项重大改进，即对动态语言的支持，...通过深入理解Spring的动态语言支持和Groovy的特性，开发者可以构建出更加适应变化、响应迅速的企业级应用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值