FLEX4.6+SPEING3.0.5+HIBERNATE3.6集成

最新推荐文章于 2024-03-06 11:19:02 发布
最新推荐文章于 2024-03-06 11:19:02 发布
阅读量1.5k 收藏
点赞数
分类专栏： Flex
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/neil89/article/details/9023305
版权 

 工具准备：myeclipse8.6、flex4.6、SPEING3.0.5、HIBERNATE3.6；

      环境的搭建过程这里省略。

一、创建Flex web 工程。flex4.6与以前的版本不一样，当创建一个flex项目后，本flex项目就是一个web项目，可以直接部署到tomcat中；


修改输出文件夹为WebRoot,单击“应用”，然后切换到“Flex构建路径”，检查地址；



检查无误后确定。然后将项目部署到tomcat6.0，运行项目，这样一个新的项目就部署好。


二、集成SPRING3.0.5

第一步：修改flex.class.path路径

修改web配置，如下，修改前

<context-param>
		<param-name>flex.class.path</param-name>
		<param-value>/WEB-INF/flex/hotfixes,/WEB-INF/flex/jars</param-value>
</context-param>

修改后 

<context-param>
	<param-name>flex.class.path</param-name>
	<param-value>/WEB-INF/lib</param-value>
</context-param>


第二步：集成SPRING3.0.5

下载spring包，Spring官网http://www.springsource.org，下载spring-framework-3.0.5.RELEASE.zip版本，解压后拷贝dist目录下的包到工程lib下。

第三步：让Spring来管理 MessageBroker

创建flex-application-config.xml，配置flex:message-broker，文件内容如下

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:flex="http://www.springframework.org/schema/flex"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="   
        http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
        http://www.springframework.org/schema/flex   
        http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
	
    <flex:message-broker/> 
    
</beans>

修改web.xml配置文件MessageBroker Servlet；修改前

<!-- MessageBroker Servlet -->
	<servlet>
		<servlet-name>MessageBrokerServlet</servlet-name>
		<servlet-class>flex.messaging.MessageBrokerServlet</servlet-class>
		<init-param>
			<param-name>services.configuration.file</param-name>
			<param-value>/WEB-INF/flex/services-config.xml</param-value>
		</init-param>
		<init-param>
			<param-name>flex.write.path</param-name>
			<param-value>/WEB-INF/flex</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

修改后： 

<!-- MessageBroker Servlet -->
    <servlet>
        <servlet-name>MessageBrokerServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>
                         classpath:flex-application-config.xml,
				         classpath:resource/spring/**/application*.xml
		    </param-value>
       </init-param>
       <init-param>
			<param-name>flex.write.path</param-name>
			<param-value>/WEB-INF/flex</param-value>
		</init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

为保证工程正常启动还需要依赖如下jar包

org.springframework.flex-1.0.3.RELEASE.jar

aopalliance-1.0.0.jar

cglib-2.2.0.jar


第四步：集成HIBERNATE3.6

下载Hibernate3.6，hibernate官网http://www.hibernate.org，下载hibernate-distribution-3.6.4.Final-dist.zip，解压后将hibernate3.jar包和lib\required的必须依赖包，lib\jpa下的包拷贝到工程lib下。

 

在目录com.demo.common.dao下创建泛型DAO，只供测试，内容如下：

package com.demo.common.dao;

import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

@SuppressWarnings("unchecked")
public class HibernateEntityDao<T>  extends HibernateDaoSupport {

	private Class<T> entityClass;
	
	public void setEntityClass(Class<T> entityClass) {
		this.entityClass = entityClass;
	}

	public List executeSQLRetMap(final String sql,final Object... values) {

		return (List)getHibernateTemplate().execute(new HibernateCallback() {
			public Object doInHibernate(Session session) {
				Query query = session.createSQLQuery(sql);
				for (int i = 0; i < values.length; i++) {
					query.setParameter(i, values[i]);
				}
				return query.setResultTransformer(CriteriaSpecification.ALIAS_TO_ENTITY_MAP).list();
			}

		});
	}
}

在scr/resource/properties目录下创建数据库连接配置


内容如下dbconfig.properties

#DataBase Type, Oracle DataBase Set Value Oracle, SQLServer DataBase Set Value SQLServer, MySQL DataBase set Value MySQL
#dataBaseType=Oracle
dataBaseType=SQLServer
#SQLServer
jdbc.driverClassName=com.microsoft.sqlserver.jdbc.SQLServerDriver
jdbc.url=jdbc:sqlserver://localhost:1433;DatabaseName=test
jdbc.username=sa
jdbc.password=123
hibernate.dialect=com.demo.common.dao.SqlServerDialect

jdbc.initialPoolSize=5
#Output SQL statements to console,true:yes ,false:no
hibernate.show_sql=true
#Inquires the cache true:yes ,false:no
hibernate.cache.use_query_cache=true
hibernate.substitutions=true 1, false 0, yes 'Y', no 'N'
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider
hibernate.jdbc.batch_size=50

log4j. properties内容如下：

log4j.rootLogger=ERROR,fileout,stdout


log4j.logger.monitorLogger=ERROR,monitorAppender
log4j.additivity.monitorLogger=false

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d (%F:%L) %-5p %c - %m%n

log4j.appender.fileout=org.apache.log4j.DailyRollingFileAppender
log4j.appender.fileout.File=D:/logs/wwfsgcjs_log.txt
log4j.appender.fileout.layout=org.apache.log4j.PatternLayout
log4j.appender.fileout.layout.ConversionPattern=%d [%t] (%F:%L) %-5p %c - %m%n

log4j.appender.monitorAppender=org.apache.log4j.DailyRollingFileAppender
log4j.appender.monitorAppender.File=D:/logs/mt_wwfsgcjs_log.txt
log4j.appender.monitorAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.monitorAppender.layout.ConversionPattern=%m%n

log4j.appender.monitorAppender.DatePattern='.'yyyy-MM-dd-HH
log4j.appender.monitorAppender.BufferedIO=true

log4j.appender.monitorAppender.BufferSize=8192

在scr/resource/spring创建

applicationContext.xml及applicationContext-db.xml文件，内容如下

applicationContext.xml


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:flex="http://www.springframework.org/schema/flex"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    xsi:schemaLocation="   
        http://www.springframework.org/schema/beans   
        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
        http://www.springframework.org/schema/flex   
        http://www.springframework.org/schema/flex/spring-flex-1.0.xsd">
	
   <!-- org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean -->
	<!--<bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
		<property name="configLocation">
			<value>classpath:hibernate.cfg.xml</value>
		</property>
	</bean> -->
   <!-- 事务管理器，将委托给HibernateTransactionManager进行管理//-->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate3.HibernateTransactionManager">
		<property name="sessionFactory" ref="sessionFactory" />
	</bean>

	<!-- 事务处理的AOP配置 所有服务层bean声明都要继承此bean ,在proxy里没有定义target属性，所以一定要在bean里加上 abstract="true"  //-->
	<bean id="TransactionProxyTemplate" abstract="true"
		class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<property name="transactionManager" ref="transactionManager" />
		<property name="transactionAttributes">
			<props>
				<!-- 为了保证服务层统一的事务处理。服务层接口，类的方法必须以下面的方法为开头  -->
				<!--spring 捕获到RuntimeException和其他一些异常时才会回滚，不是所有异常都会回滚，-Exception 设置 为任何异常都回滚  -->
				<prop key="user*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="query*">PROPAGATION_REQUIRED,readOnly</prop>
				<prop key="save*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="insert*">
					PROPAGATION_REQUIRED,-Exception
				</prop>
				<prop key="add*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="up*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="mod*">PROPAGATION_REQUIRED,-Exception</prop>
				<prop key="delete*">
					PROPAGATION_REQUIRED,-Exception
				</prop>
				<prop key="remove*">
					PROPAGATION_REQUIRED,-Exception
				</prop>
				<prop key="create*">
					PROPAGATION_REQUIRED,-Exception
				</prop>
				<prop key="execute*">
					PROPAGATION_REQUIRED,-Exception
				</prop>
				<prop key="do*">PROPAGATION_REQUIRED,-Exception</prop>
			</props>
		</property>
	</bean>
	
	<!-- 提供普java类获取spring上下文 通过上下文获取具体bean,调用其中的方法 -->
	<bean id="springApplicationContextUtil" class="com.demo.util.SpringApplicationContextUtil"></bean>
	
	<!-- 系统初始化的时候读取数据库配置文件配置的数据库类型 -->
	<bean class="com.demo.util.DBPropertiesUtil" lazy-init="false" init-method="init" />
	
	<!-- 基础DAO ，针对一些业务没有具体实体类，比如调用存储过程，但又要能使用泛型DAO的方法 -->
	<bean id="baseDAO" class="com.demo.common.dao.HibernateEntityDao">
		<property name="sessionFactory" ref="sessionFactory" />
		<property name="entityClass" value="java.lang.Object" />
	</bean>
		
	
</beans>

applicationContext-db.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"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <!-- To provide a placeholder, mainly for database configuration -->
	 <bean id="propertyConfigure" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> 
	     <property name="locations">
	        <list>
	        	<value>classpath:resource/properties/dbconfig.properties</value>
	        </list>
	     </property>
 	 </bean>
    <!--Database connection pool configuration -->
    <bean id="sysDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
      <property name="driverClass"><value>${jdbc.driverClassName}</value></property>
      <property name="jdbcUrl"><value>${jdbc.url}</value></property>
      <property name="user"><value>${jdbc.username}</value></property>
      <property name="password"><value>${jdbc.password}</value></property>
      <property name="initialPoolSize"><value>${jdbc.initialPoolSize}</value></property>
    </bean>
	
    <bean id="sessionFactory"
		class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
		
		<property name="dataSource">
			<ref bean="sysDataSource" />
		</property>
<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">${hibernate.dialect}</prop>
				<prop key="hibernate.show_sql">${hibernate.show_sql}</prop>  
                <prop key="hibernate.cache.provider_class">${hibernate.cache.provider_class}</prop>
                <prop key="hibernate.cache.use_query_cache">${hibernate.cache.use_query_cache}</prop>
                <prop key="hibernate.jdbc.batch_size">${hibernate.jdbc.batch_size}</prop>
			</props>
		</property>
		
		<!--<property name="mappingResources">
			<list>
			<value></value>
		   </list>
		</property>	-->
		
		 <!--  文件夹映射 -->
		 <property name="mappingDirectoryLocations">
		 	<list>
		 		<value>WEB-INF/classes/com/demo/</value>
		 	</list>
		 </property>
		
		<!-- 注解方式映射 -->
		 <property name="packagesToScan">
		 	<list>
		 	<value>com.demo.*</value>
		 	</list>
		</property>
   </bean>

下面是一些需要用到的类



SqlServerDialect.java

package com.demo.common.dao;

import java.sql.Types;

import org.hibernate.dialect.SQLServer2008Dialect;
import org.hibernate.type.DoubleType;
import org.hibernate.type.StringType;

public class SqlServerDialect extends SQLServer2008Dialect {
	
	 public SqlServerDialect() {
		super();
		registerHibernateType(Types.CHAR, StringType.INSTANCE.getName());
		registerHibernateType(Types.NVARCHAR, StringType.INSTANCE.getName());
		registerHibernateType(Types.LONGNVARCHAR, StringType.INSTANCE.getName());
		registerHibernateType(Types.DECIMAL, DoubleType.INSTANCE.getName());
		registerHibernateType(Types.NCHAR,StringType.INSTANCE.getName());
	}
}

DBPropertiesUtil.java

package com.demo.util;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import org.apache.commons.lang.StringUtils;
public final  class DBPropertiesUtil {
	
	private DBPropertiesUtil(){		
	}
	//数据库类型
	private static String dataBaseType;	
	/**
     * 初始化方法 bean 中配置
     * init-method="init" 
     */
    public void init() {
	   Properties prop = new Properties();
	   InputStream in = DBPropertiesUtil.class.getResourceAsStream("/resource/properties/dbconfig.properties");
	   try {
	       prop.load(in);
	       dataBaseType = StringUtils.trim(prop.getProperty("dataBaseType")); 
	   } catch (IOException e) {
	  	  System.out.println("读取 /resource/properties/dbconfig.properties 配置数据库类型错误！");
	      e.printStackTrace();
	   }
    }
	
	/**
	 * 获取dbconfig.properties文件中配置数据库类型
	 * @return
	 */
	public static String getDataBaseType() {
		if (StringUtils.isBlank(dataBaseType)) {
			dataBaseType = "ORACLE";
		}
		return dataBaseType;
	}	
}

下面，在com.demo.service.imp下新建一个实现类

在类中添加

private HibernateEntityDao<Object>baseDAO;

private HibernateEntityDao<Test>testDAO;



在弹出的对话框中选择两个setter，并生成类，最后生成的内容如下

package com.demo.service.imp;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.demo.common.dao.HibernateEntityDao;
import com.demo.pojo.Test;
import com.demo.service.TestService;
public class TestServiceImp implements TestService {
	private HibernateEntityDao<Object> baseDAO;
	private HibernateEntityDao<Test> testDAO;
	public void setBaseDAO(HibernateEntityDao<Object> baseDAO) {
		this.baseDAO = baseDAO;
	}
	public void setTestDAO(HibernateEntityDao<Test> testDAO) {
		this.testDAO = testDAO;
	}
	
	@Override
	public String getStr() {
		return "HelloWorld!";
	}

	@SuppressWarnings("unchecked")
	public List getList(Map<String, String> o) throws Exception {
		String sql="select * from TEST";
		System.out.println(sql);
		List list =baseDAO.executeSQLRetMap(sql.toString());
		return list;
	}

}

在src/resource/spring/demo目录下创建配置文件

applicationContext-test.xml,内容如下

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

	<bean id="testt" parent="TransactionProxyTemplate">
		<flex:remoting-destination />
		<property name="target">
			<bean class="com.demo.test">
			</bean>
		</property>
	</bean>
	
	<bean id="te" parent="TransactionProxyTemplate">
		<flex:remoting-destination />
		<property name="target">
			<bean class="com.demo.service.imp.TestServiceImp">
			</bean>
		</property>
	</bean>
	
	<!--Service -->
	<bean id="testService" parent="TransactionProxyTemplate">
		<flex:remoting-destination/>
		<property name="target">
			<bean class="com.demo.service.imp.TestServiceImp">
				<property name="testDAO" ref="testDAO"/>
				<property name="baseDAO" ref="baseDAO"/>
			</bean>
		</property>
	</bean>
	
	<!--DAO -->
	<bean id="testDAO" class="com.demo.common.dao.HibernateEntityDao">
		<property name="sessionFactory" ref="sessionFactory"/>
		<property name="entityClass" value="com.demo.pojo.Test"/>
	</bean>
</beans>

 

接着，在flex_src/com/util目录下创建

Config.as，用作前后台交互

package com.util {
	import mx.messaging.config.ServerConfig;

	public class Config {
		private static var _path:String;

		public static function get path():String {
			if (Config._path) {
				return Config._path;
			} else {
				var point:String = ServerConfig.getChannel("my-amf", false).endpoint;
				var index:int = point.indexOf("/WebRoot/messagebroker/amf");
				point = point.substring(0, index);
				if(point.lastIndexOf("/") !=-1){
					return point;
				}
				return point + "/";
			}
		}
	}
}


ServiceProxy.as

package com.util {
	import flash.net.URLRequest;
	import flash.net.navigateToURL;

	import mx.controls.Alert;
	import mx.events.CloseEvent;
	import mx.rpc.AbstractOperation;
	import mx.rpc.AsyncResponder;
	import mx.rpc.AsyncToken;
	import mx.rpc.events.FaultEvent;
	import mx.rpc.events.ResultEvent;
	import mx.rpc.remoting.RemoteObject;


	public class ServiceProxy {
		public static function execute(destination:String, method:String, onResult:Function, ... params:Array):void {
			var service:RemoteObject = new RemoteObject(destination);
			service.showBusyCursor = true;
			service.endpoint = Config.path + '/syFrame/messagebroker/amf';
			Alert.show(Config.path);
			var asyncToken:AsyncToken;
			var operation:AbstractOperation = service.getOperation(method);
			if (params && params.length != 0) {
				asyncToken = operation.send.apply(operation, params);
			} else {
				asyncToken = operation.send();
			}
			asyncToken.addResponder(new AsyncResponder(function(event:ResultEvent, asyncToken:AsyncToken):void {
				onResult(event);
			}, function(event:FaultEvent, asyncToken:AsyncToken):void {
				var msg:String = event.fault.rootCause;
				if (msg && msg.hasOwnProperty('cause') && msg.cause) {
					msg = msg.cause.message;
				} else {
					msg = event.fault.faultString;
					msg = msg.replace('java.lang.Exception :', '');
				}
				Alert.show(msg, '警告', 0x4, null, function(event:CloseEvent):void {
					if (msg && msg.indexOf('请重新登录') != -1)
						navigateToURL((new URLRequest("javascript:location.reload()")), "_self");
				});
			}, asyncToken));
		}
	}
}

在flex应用程序中，添加测试代码，test.mxml内容如下

<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009" 
			   xmlns:s="library://ns.adobe.com/flex/spark" 
			   xmlns:mx="library://ns.adobe.com/flex/mx" minWidth="955" minHeight="600">
	<fx:Declarations>
		<!-- 将非可视元素（例如服务、值对象）放在此处 -->
	</fx:Declarations>
	<fx:Script>
		<![CDATA[
			import com.util.ServiceProxy;
			
			import mx.collections.ArrayCollection;
			import mx.controls.Alert;
			import mx.rpc.events.ResultEvent;
			private function clickHandler():void{
				ServiceProxy.execute("testt","getTest",RE,txt.text);
			}
			private function RE(e:ResultEvent):void{
				txt.text=e.result.toString();
			}
			
			private function clickHandler2():void{
				var o:Object=new Object();
				o.STNM="n";
				ServiceProxy.execute("testService","getList",RE2,o);
			}
			private function RE2(e:ResultEvent):void{
				var list:ArrayCollection=e.result as ArrayCollection;
				Alert.show(list.length.toString());
			}
			
		]]>
	</fx:Script>
	<s:Button x="154" y="174" label="Button" click="clickHandler()"/>
	<s:TextInput id="txt" x="118" y="93"/>
	
	<s:Button x="279" y="174" label="查询数据库" click="clickHandler2()"/>
</s:Application>

第五步：实体生成

新建别一个项目，通过向导，添加hibernate



Myeclipse切换到数据库透视图，连接到需要生成实体的数据库







在弹出对话框中选择注解方式生成实体，如下


生成实体后，只保留name属性，如下图



以上是全部的步骤了，虽然顺序上不够严谨，但最后测试结果是可以的。












neil89
关注
专栏目录
springboot+rabbitMq存储日志到数据库
zlhmeng的博客
10-22 3641
“止于唇齿的热爱最廉价，如果不是一起到最后的那个人，那一个人一辈子又有何妨“” 概述 spring提供了AmqpTemplate使用rabbitmq,使用起来非常的方便，有关rabbitmq的介绍网上已经有了很多很好的文章 开始搬砖 implementation('org.springframework.boot:spring-boot-starter-amqp') maven项目自己转一下 ...
SpringBoot+Vue+ElementUI实现文件上传
weixin_44960905的博客
08-15 1237
文件上传
Springboot2 + Jdk11 jdk8 + mybatisPlus + Sqlserver2008R2 项目集成
最新发布
OnMyWaySc的博客
03-06 674
公司用的这个数据库服了, 又老,而且没玩过, 吐槽结束经过了我大量从网上借鉴,并且自身反复试验之后, 一套可行的方案如下。
前后端（react+springboot）服务器部署
qq_43907296的博客
11-15 2374
前后端（react+springboot）服务器部署
【持久化框架】SpringMVC+Spring4+Mybatis3集成
CODE男孩的博客
08-22 469
1、安装JDK1.6以上版本，安装与配置 2、下载mybatis-3.2.0版：https://repo1.maven.org/maven2/org/mybatis/mybatis/ 3、下载mybatis-spring-1.2.1版：https://repo1.maven.org/maven2/org/mybatis/mybatis-spring/ 4、Spring-4.0.0
springboot + redission 实现分布式锁
a863922230的专栏
11-07 1526
使用springboot 2.2.2 ，redis 3.4 首先这里的pom文件如下： <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.5.0</version> </dependency> <dependency> <groupId
activiti与spring集成
苏凯的博客
10-19 1034
  摘要： 一、集成配置 &lt;bean id="dataSource" class="org.springframework.jdbc.datasource.SimpleDriverDataSource"&gt;     &lt;property name="driverClass" value="org. 一、集成配置 &lt;bean id="dataSource" 
Speing-Boot学习 搭建一个简单的Spring-boot + mybatis
qq_32844875的博客
10-30 686
首先先来认识一下Spring-boot框架，该框架是对Spring框架的进一步集成，设计目的就是简化Spring应用的搭建和开发过程。优点如下： 对第三方插件封装和整合，提供第三方接口 无需配置复杂的XML 提供安全等特性 核心功能-自动配置 内嵌式 web服务器（Tomcat、Jetty等） 提供POM，简化Maven配置 接下来，搭建一个最简单的spring-boot+mybati...
SpringBoot+Vue前后端分离，使用SpringSecurity完美处理权限问题(六)
热门推荐
江南一点雨的专栏
01-23 1万+
当前后端分离时，权限问题的处理也和我们传统的处理方式有一点差异。笔者前几天刚好在负责一个项目的权限管理模块，现在权限管理模块已经做完了，我想通过5-6篇文章，来介绍一下项目中遇到的问题以及我的解决方案，希望这个系列能够给小伙伴一些帮助。本系列文章并不是手把手的教程，主要介绍了核心思路并讲解了核心代码，完整的代码小伙伴们可以在GitHub上star并clone下来研究。另外，原本计划把项目跑起来放到
speing mybatis springmvc
01-05
SSM框架，即Spring、MyBatis和SpringMVC的组合，是Java开发Web应用时常用的三大组件。Spring作为核心容器，负责管理对象及其依赖关系；MyBatis是一个优秀的持久层框架，它支持定制化SQL、存储过程以及高级映射；...
spring与mybatis整合配置文档
08-05
##### 2.3 MyBatis集成配置 为了使Spring与MyBatis协同工作，需配置`SqlSessionFactory` Bean，指定MyBatis全局配置文件位置及Mapper文件的位置。 ```xml *.xml"/> ``` 同时，为了提高性能，还可以配置批量...
speing batch demo
11-24
项目中可能包含测试用例，使用JUnit或其他测试框架，对批处理作业进行单元测试和集成测试，确保正确性和性能。 总的来说，"spring batch demo"是一个实用的学习资源，它涵盖了Spring Batch的核心特性和实际应用，...
speing mvc
10-14
好的，你的问题是： spring mvc 是什么？ 回答： Spring MVC 是 Spring Framework 的...Spring MVC 提供了一种灵活的方式来开发 Web 应用程序，它可以与其他 Spring 框架集成，如 Spring Security、Spring Data 等。
Flex手机项目继承IconItemRenderer自定义List组件
尼乐
12-21 6303
在学习Flex手机项目的过程中，用到了List组件。系统默认的List有两种形式，一种是只显示一行文件的LabelItemRenderer简单样式，另一种为继承了LabelItemRenderer样式的IconItemRenderer样式。后一种相对比较复杂，在每个item中可以添加图片，图标，多行文件等内容。但是如果认真可以发现，后一种还是不能满足各种项目需求，例如想在每个item里添加一个"修
arcgis api for Flex画贝赛尔曲线
尼乐
02-04 5761
最近在研究用arcgis api for Flex客户端动态画曲线的问题。虽然花了不少时间，最终等值线还是没有预期效果那样画在地图之上，但还是有不少收获。画等值线过程中，需要利用贝赛尔曲线函数来画平滑曲线。网上找了很多资料，都是在用flash环境中的curveTo()方法来画，但是好像这样画出来的曲线是不能在gis图层中显示的，即只能在flash.display.Graphics下的graphic
ArcGIS API For Flex4+Papervision3d实现3D地图浏览
尼乐
11-05 5703
在本讨论坛中见过另一个博主写过本篇相同的内容。但是其博客上只讲了大概思路，如果不是papervision3d方面比较熟的人还真难看懂。本人GIS出身，对他这篇博文颇感兴趣，因此看了多遍，但有很多地方还是没有看明白，我想过另一种办法，实现了，不过还是感谢那位仁兄，给了我不少灵感。 上图先 实现原理就是将2D环境下的map control添加到3D场景中，这样，就可以对map control进
查看flex中的swc包源码文件
尼乐
06-01 4858
工具：硕思闪客精灵、RAR解压工具 步骤：1、先用RAR解压工具查看swc文件，然后导出里面的library.swf文件；     2、打开闪客精灵，导入这个library.swf文件，在右边的地方会显示相关的资源，里面有个脚本目录，如图，是不是找到了你想要的东西；
Flex4.6手机项目+arcgis api+瓦片地图
尼乐
01-08 4336
昨日看到一个牛人发的一篇博文，内容是利用arcgis api for flex读取自定义瓦片地图。我一想，能不能做Flex4.6手机项目读取本地地图缓存。经过两天的捣鼓，终于在我的爱机上显示预先切好的瓦片地图，欢喜。贴上代码： MyLayer.as package map { import com.esri.ags.SpatialReference; import com.esri.a
Flex+Papervision3D三维技术研究（基础篇一）
尼乐
11-05 3665
在上一篇上讲到了开发工具及包需要的包，下面让我们动手来实现一下第一个3D场景。 1、在eclipse中新建一个flex项目，添加Papervision3D.swc包到flex_libs中，设置好目录结构。上图 2、在as包下添加一个as类继承UIComponent，命名为Map3D.as 3、实现第一个3D场景，在场景中添加一个Panel平面，并让这个平面绕Z轴旋转，上代
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值