pip安装包到指定目录方法(指定路径)

 mac, pip, python  pip安装包到指定目录方法(指定路径)已关闭评论
10月 242019
 

mac中使用pip安装包后,可能会发现明明提示“Successfully installed xxx“,但就是找不到这个包“ImportError: No module named  xxx”?

其实是这样: 默认pip安装在/usr/local/lib/python2.7/site-packages, 但如果sudo pip安装则会安装在/lib/python2.7/site-packages,那如果我要指定安装包的路径需要怎么做呢?使用下面的黑体字命令即可,在-install-option里添加–install-purelib指定目录即可,以下命令安装google-api-python-client包到/usr/local/lib/python2.7/site-packages

pip install --install-option="--install-purelib=/usr/local/lib/python2.7/site-packages" google-api-python-client

 

DONE!!!

Mybatis中实体类属性和数据列之间映射的四种办法

 开发  Mybatis中实体类属性和数据列之间映射的四种办法已关闭评论
12月 292018
 

网上总结的4个方法,挺好的,分享下: https://blog.csdn.net/lmy86263/article/details/53150091

首先先定义一个测试实体类,如下:

public class User implements Serializable {
    private Integer userId;
    private String userName;
    ……
}

1. 通过XML映射文件中的resultMap

这种方式是最常见的,类似如下:

<mapper namespace=”data.UserMapper”>
    <resultMap type=”data.User” id=”userResultMap”>
        <!– 用id属性来映射主键字段 –>
        <id property=”id” column=”user_id”/>
        <!– 用result属性来映射非主键字段 –>
        <result property=”userName” column=”user_name”/>
    </resultMap>
</mapper>
通过里面的id标签和result标签来建立映射关系,由property和column分别指定实体类属性和数据表的列名。

2. 通过注解@Results和@Result

这两个注解是与XML文件中的标签相对应的:

@Results对应resultMap
@Result对应result
这两个注解是应用在方法的级别上的,也就是在mapper方法上,如下:

@Select(“select * from t_user where user_name = #{userName}”)
@Results(
        @Result(property = “userId”, column = “user_id”),
        @Result(property = “userName”, column = “user_name”)
)
User getUserByName(@Param(“userName”) String userName);
缺点:

由于注解是针对方法的,对于Mapper中的每个操作数据库的方法都必须有相同的注解完成映射关系的建立,导致很多的配置是重复的;
如果要避免配置重复的问题,可以采用在XML配置文件中配置这个resultMap,然后再@Result中通过id属性引用这个resultMap, 
但是这样感觉很麻烦(由于使用了两种配置方式),不如直接使用基于XML的resultMap配置方式;
3. 通过属性配置完成映射

使用者最陌生的是通过配置属性来完成映射,Mybatis给我们提供了一种映射方式,如果属性的命名是遵从驼峰命名法的,数据列名遵从下划线命名, 
那么可以使用这种方式,类似如下:

userName对应user_name;
userId对应user_id;
配置代码如下:

SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
Configuration configuration = new Configuration();
configuration.setMapUnderscoreToCamelCase(true);
sqlSessionFactoryBean.setConfiguration(configuration);

4. 通过使用在SQL语句中定义别名完成映射

这种方式最直接,直接在SQL语句中建立别名来完成映射,如下:

@Select(“select user_name as userName, user_id as userId from t_user where user_name = #{userName}”)
User getUserByName(@Param(“userName”) String userName);

Javascript 创建对象方法的总结

 javascript  Javascript 创建对象方法的总结已关闭评论
7月 142017
 

网上找到的资料,记录下,免得下次再找了,http://www.cnblogs.com/wangjq/p/3755691.html

使用Javascript创建对象的方法有很多,现在就来列举一下:

1. 使用Object构造函数来创建一个对象,下面代码创建了一个person对象,并用两种方式打印出了Name的属性值。

    var person = new Object();
    person.name="kevin";
    person.age=31;
    alert(person.name);
    alert(person["name"])

2. 使用对象字面量创建一个对象;不要奇怪person[“5”],这里是合法的;另外使用这种加括号的方式字段之间是可以有空格的如person[“my age”].

复制代码
    var person = {
        name:"Kevin",
        age:31, 5:"Test" };
    alert(person.name);  alert(person["5"]);
复制代码

3. 使用工厂模式创建对象,返回带有属性和方法的person对象。

复制代码
function createPerson(name, age,job)
{ var o = new Object();
    o.name=name;
    o.age=31;
    o.sayName=function()
    {
        alert(this.name);
    }; return o;
}
createPerson("kevin",31,"se").sayName();
复制代码

4. 使用自定义构造函数模式创建对象;这里注意命名规范,作为构造函数的函数首字母要大写,以区别其它函数。这种方式有个缺陷是sayName这个方法,它的每个实例都是指向不同的函数实例,而不是同一个。

复制代码
function Person(name,age,job)
{ this.name=name; this.age=age; this.job=job; this.sayName=function()
    {
        alert(this.name);
    };
} var person = new Person("kevin",31,"SE");
person.sayName();
复制代码

5. 使用原型模式创建对象;解决了方法4中提到的缺陷,使不同的对象的函数(如sayFriends)指向了同一个函数。但它本身也有缺陷,就是实例共享了引用类型friends,从下面的代码执行结果可以看到,两个实例的friends的值是一样的,这可能不是我们所期望的。

复制代码
function Person()
{

}

Person.prototype = {
    constructor : Person,
    name:"kevin",
    age:31,
    job:"SE",
    friends:["Jams","Martin"],
    sayFriends:function()
    {
        alert(this.friends);
    }
}; var person1 = new Person();
person1.friends.push("Joe");
person1.sayFriends();//Jams,Martin,Joe
var person2 = new Person(); 
person2.sayFriends();//James,Martin,Joe
复制代码

6. 组合使用原型模式和构造函数创建对象,解决了方法5中提到的缺陷,而且这也是使用最广泛、认同度最高的创建对象的方法。

复制代码
function Person(name,age,job)
{ this.name=name; this.age=age; this.job=job;
   this.friends=["Jams","Martin"];
}
Person.prototype.sayFriends=function()
{
    alert(this.friends);
}; var person1 = new Person("kevin",31,"SE");
var person2 = new Person("Tom",30,"SE");
person1.friends.push("Joe");
person1.sayFriends();//Jams,Martin,Joe
person2.sayFriends();//Jams,Martin
复制代码

 7. 动态原型模式;这个模式的好处在于看起来更像传统的面向对象编程,具有更好的封装性,因为在构造函数里完成了对原型创建。这也是一个推荐的创建对象的方法。

复制代码
function Person(name,age,job)
{ //属性 this.name=name; this.age=age; this.job=job; this.friends=["Jams","Martin"]; //方法 if(typeof this.sayName !="function")
    {
        Person.prototype.sayName=function()
        {
            alert(this.name);
        };
        
        Person.prototype.sayFriends=function()
        {
            alert(this.friends);
        };
    }
} var person = new Person("kevin",31,"SE");
person.sayName();
person.sayFriends();
复制代码

另外还有两个创建对象的方法,寄生构造函数模式和稳妥构造函数模式。由于这两个函数不是特别常用,这里就不给出具体代码了。

写了这么多创建对象的方法,其实真正推荐用的也就是方法6和方法7。当然在真正开发中要根据实际需要进行选择,也许创建的对象根本不需要方法,也就没必要一定要选择它们了。

Maven打包可执行Jar的几种方法

 MAVEN  Maven打包可执行Jar的几种方法已关闭评论
11月 292016
 

一、无依赖其他任何jar

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.4</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.think.TestMain</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>

运行:mvn clean package,在target中找到打包出来的,命令后运行java -jar xxx.jar即可,但是如果程序有依赖其他包,比如程序依赖jdbc去查询db,这时候再执行就会出现找不到jdbc依赖,因为我们并没有将依赖包打进去

二、解决依赖其他包时,可执行jar的打包

1、

<build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <appendAssemblyId>false</appendAssemblyId>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifest>
                            <mainClass>com.think.TestMain</mainClass>
                        </manifest>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>assembly</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

但以上方式用的比较少,因为我们依赖的jar,也会打进到我们最终生成的jar,这样不太好,假如你生成的jar要给别人使用,最好给一个纯净的。

一般用assembly会再用他另外一个功能,将我们的jar归档,打包成一个zip

2、打成一个zip包,发布项目的时候,将zip包copy到服务器上,直接unzip xxx.zip,里面包含要运行到jar以及依赖的lib,还有配置的config文件,即可直接启动服务

<build>
        <resources>
            <!-- 控制资源文件的拷贝 -->
            <resource>
                <directory>src/main/resources</directory>
                <targetPath>${project.build.directory}/classes</targetPath>
            </resource>
        </resources>
        <plugins>
            <!-- 设置源文件编码方式 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- The configuration of maven-jar-plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.4</version>
                <!-- The configuration of the plugin -->
                <configuration>
                    <!-- Configuration of the archiver -->
                    <archive>

                        <!--
                            生成的jar中,不要包含pom.xml和pom.properties这两个文件
                        -->
                        <addMavenDescriptor>false</addMavenDescriptor>

                        <!-- Manifest specific configuration -->
                        <manifest>
                            <!--
                                是否要把第三方jar放到manifest的classpath中
                            -->
                            <addClasspath>true</addClasspath>
                            <!--
                               生成的manifest中classpath的前缀,因为要把第三方jar放到lib目录下,所以classpath的前缀是lib/
                           -->
                            <classpathPrefix>lib/</classpathPrefix>
                            <!--
                                应用的main class
                            -->
                            <mainClass>com.think.TestMain</mainClass>
                        </manifest>
                    </archive>
                    <!--
                        过滤掉不希望包含在jar中的文件
                    -->
                    <!--<excludes>-->
                        <!--<exclude>${project.basedir}/xml/*</exclude>-->
                    <!--</excludes>-->
                </configuration>
            </plugin>

            <!-- The configuration of maven-assembly-plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.4</version>
                <!-- The configuration of the plugin -->
                <configuration>
                    <!-- Specifies the configuration file of the assembly plugin -->
                    <descriptors>
                        <descriptor>src/main/assembly/assembly.xml</descriptor>
                    </descriptors>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

还有一个重要的文件,名字可以随便起,我上面用的是 src/main/assembly/assembly.xml

<assembly>
    <id>bin</id>
    <includeBaseDirectory>false</includeBaseDirectory>
    <!-- 最终打包成一个用于发布的zip文件 -->
    <formats>
        <format>zip</format>
    </formats>

    <!-- Adds dependencies to zip package under lib directory -->
    <dependencySets>
        <dependencySet>
            <!--
               不使用项目的artifact,第三方jar不要解压,打包进zip文件的lib目录
           -->
            <useProjectArtifact>false</useProjectArtifact>
            <!--<outputDirectory>lib</outputDirectory>-->
            <unpack>false</unpack>
        </dependencySet>
    </dependencySets>

    <fileSets>
        <!-- 把项目相关的说明文件,打包进zip文件的根目录 -->
        <!--<fileSet>-->
            <!--<directory>${project.basedir}</directory>-->
            <!--<outputDirectory>/</outputDirectory>-->
        <!--</fileSet>-->

        <!-- 把项目的配置文件,打包进zip文件的config目录 -->
        <fileSet>
            <directory>${deploy.dir}/classes/</directory>
            <outputDirectory>/conf</outputDirectory>
            <includes>
                <include>*.xml</include>
                <include>*.properties</include>
            </includes>
        </fileSet>
        <!-- 把项目自己编译出来的jar文件,打包进zip文件的根目录 -->
        <fileSet>
            <directory>${project.build.directory}</directory>
            <outputDirectory></outputDirectory>
            <includes>
                <include>*.jar</include>
            </includes>
        </fileSet>
    </fileSets>
</assembly>

最终执行命令:mvn clean package,出来的是这样的

解压zip包,我们看到我们想要的,good

3、还有一种打包方式,上面相当于把我们想要的东西打成一个zip包,全部放到一起,看着整洁好看,但有点繁琐,我们其实可以用另外一个插件来完成,不打包,即看到上图解压后的文件

<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.test</groupId>
    <artifactId>myTestJar</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>myTestJar</name>
    <url>http://maven.apache.org</url>

    <properties>
        <deploy.dir>./target/</deploy.dir>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>3.8.1</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.9</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.32</version>
        </dependency>
    </dependencies>

    <build>
        <finalName>myTest</finalName>
        <sourceDirectory>src/main/java</sourceDirectory>
        <resources>
            <!-- 控制资源文件的拷贝 -->
            <resource>
                <directory>src/main/resources</directory>
                <targetPath>${project.build.directory}</targetPath>
            </resource>
        </resources>
        <plugins>
            <!-- 设置源文件编码方式 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <defaultLibBundleDir>lib</defaultLibBundleDir>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- 打包jar文件时,配置manifest文件,加入lib包的jar依赖 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <classpathPrefix>lib/</classpathPrefix>
                            <mainClass>com.think.TestMain</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <!-- 拷贝依赖的jar包到lib目录 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <executions>
                    <execution>
                        <id>copy</id>
                        <phase>package</phase>
                        <goals>
                            <goal>copy-dependencies</goal>
                        </goals>
                        <configuration>
                            <!-- ${project.build.directory}是maven变量,内置的,表示target目录,如果不写,将在跟目录下创建/lib -->
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <!-- excludeTransitive:是否不包含间接依赖包,比如我们依赖A,但是A又依赖了B,我们是否也要把B打进去 默认不打-->
                            <excludeTransitive>true</excludeTransitive>
                            <!-- 复制的jar文件去掉版本信息 -->
                            <stripVersion>true</stripVersion>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <!-- 解决资源文件的编码问题 -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.3</version>
                <configuration>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <!-- 打包source文件为jar文件 -->
            <plugin>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <attach>true</attach>
                    <encoding>UTF-8</encoding>
                </configuration>
                <executions>
                    <execution>
                        <phase>compile</phase>
                        <goals>
                            <goal>jar</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

这里采用的是maven-dependency-plugin插件,进行资源的copy。

4、

<build>
        <resources>
            <resource>
                <targetPath>${project.build.directory}/classes</targetPath>
                <directory>src/main/resources</directory>
                <filtering>true</filtering>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.0</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                    <encoding>UTF-8</encoding>
                </configuration>
            </plugin>
            <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>
                            <transformers>
                                <transformer
                                        implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.think.TestMain</mainClass>
                                </transformer>
                                <!--<transformer-->
                                        <!--implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">-->
                                    <!--<resource>applicationContext.xml</resource>-->
                                <!--</transformer>-->
                            </transformers>
                            <shadedArtifactAttached>true</shadedArtifactAttached>
                            <shadedClassifierName>executable</shadedClassifierName>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

这种方式打出来是柔和到一起,成为一个jar,

可以直接java -jar xxx.jar运行。

我们可以根据不同需要来打包,如果暴露给外面,可以采用第4种,如果是自己公司项目打包,建议2,3种,因为有时候只是改了个配置文件,不需要打包,直接把配置文件复制进去即可

转自:http://m.blog.csdn.net/article/details?id=51871705

python操作日期和时间的方法

 python  python操作日期和时间的方法已关闭评论
8月 162016
 

python操作日期和时间的方法

不管何时何地,只要我们编程时遇到了跟时间有关的问题,都要想到 datetime 和 time 标准库模块,今天我们就用它内部的方法,详解python操作日期和时间的方法。
1.将字符串的时间转换为时间戳

复制代码代码如下:
方法:
a = “2013-10-10 23:40:00”
#将其转换为时间数组
import time
timeArray = time.strptime(a, “%Y-%m-%d %H:%M:%S”)
#转换为时间戳:
timeStamp = int(time.mktime(timeArray))
timeStamp == 1381419600

2.格式更改
如a = “2013-10-10 23:40:00”,想改为 a = “2013/10/10 23:40:00”
方法:先转换为时间数组,然后转换为其他格式

复制代码代码如下:
timeArray = time.strptime(a, “%Y-%m-%d %H:%M:%S”)
otherStyleTime = time.strftime(“%Y/%m/%d %H:%M:%S”, timeArray)

3.时间戳转换为指定格式日期
方法一:利用localtime()转换为时间数组,然后格式化为需要的格式,如:

复制代码代码如下:
timeStamp = 1381419600
timeArray = time.localtime(timeStamp)
otherStyleTime = time.strftime(“%Y-%m-%d %H:%M:%S”, timeArray)
otherStyletime == “2013-10-10 23:40:00”

方法二:

复制代码代码如下:
import datetime
timeStamp = 1381419600
dateArray = datetime.datetime.utcfromtimestamp(timeStamp)
otherStyleTime = dateArray.strftime(“%Y-%m-%d %H:%M:%S”)
otherStyletime == “2013-10-10 23:40:00”

4.获取当前时间并转换为指定日期格式
方法一:

复制代码代码如下:
import time
#获得当前时间时间戳
now = int(time.time())  ->这是时间戳
#转换为其他日期格式,如:”%Y-%m-%d %H:%M:%S”
timeArray = time.localtime(timeStamp)
otherStyleTime = time.strftime(“%Y-%m-%d %H:%M:%S”, timeArray)

方法二:

复制代码代码如下:
import datetime
#获得当前时间
now = datetime.datetime.now()  ->这是时间数组格式
#转换为指定的格式:
otherStyleTime = now.strftime(“%Y-%m-%d %H:%M:%S”)

5.获得三天前的时间的方法

复制代码代码如下:
import time
import datetime
#先获得时间数组格式的日期
threeDayAgo = (datetime.datetime.now() – datetime.timedelta(days = 3))
#转换为时间戳:
timeStamp = int(time.mktime(threeDayAgo.timetuple()))
#转换为其他字符串格式:
otherStyleTime = threeDayAgo.strftime(“%Y-%m-%d %H:%M:%S”)
注:timedelta()的参数有:days,hours,seconds,microseconds

6.给定时间戳,计算该时间的几天前时间

复制代码代码如下:
timeStamp = 1381419600
#先转换为datetime
import datetime
import time
dateArray = datetime.datetime.utcfromtimestamp(timeStamp)
threeDayAgo = dateArray – datetime.timedelta(days = 3)
#参考5,可以转换为其他的任意格式了

7、用Python计算昨天和明天的日期

复制代码代码如下:
>>> import datetime #导入日期时间模块
>>> today = datetime.date.today() #获得今天的日期
>>> print today #输出今天日期
2014-01-04 
>>> yesterday = today – datetime.timedelta(days=1) #用今天日期减掉时间差,参数为1天,获得昨天的日期
>>> print yesterday
2014-01-03 
>>> tomorrow = today + datetime.timedelta(days=1) #用今天日期加上时间差,参数为1天,获得明天的日期
>>> print tomorrow
2014-01-05 
>>>
>>> print “昨天:%s, 今天:%s, 明天:%s” % (yesterday, today, tomorrow) #字符串拼接在一起输出,这3天的日期

昨天:2014-01-03, 今天:2014-01-04, 明天:2014-01-05
8、python里使用time模块来获取当前的时间

复制代码代码如下:

#!/usr/bin/python
import time
print (time.strftime(“%H:%M:%S”))
## 12 hour format ##
print (time.strftime(“%I:%M:%S”))
#:输出
#18:11:30
#6:11:30

9、打印出当前的日期的python程序

复制代码代码如下:
!/usr/bin/python

import time
## dd/mm/yyyy格式
print (time.strftime(“%d/%m/%Y”))

#输出:
11/03/2014

10、使用datetime模块来获取当前的日期和时间

复制代码代码如下:
#!/usr/bin/python
import datetime
i = datetime.datetime.now()
print (“当前的日期和时间是 %s” % i)
print (“ISO格式的日期和时间是 %s” % i.isoformat() )
print (“当前的年份是 %s” %i.year)
print (“当前的月份是 %s” %i.month)
print (“当前的日期是  %s” %i.day)
print (“dd/mm/yyyy 格式是  %s/%s/%s” % (i.day, i.month, i.year) )
print (“当前小时是 %s” %i.hour)
print (“当前分钟是 %s” %i.minute)
print (“当前秒是  %s” %i.second)

附:日期和时间的格式化参数

复制代码代码如下:

%a 星期几的简写
%A 星期几的全称
%b 月分的简写
%B 月份的全称
%c 标准的日期的时间串
%C 年份的后两位数字
%d 十进制表示的每月的第几天
%D 月/天/年
%e 在两字符域中,十进制表示的每月的第几天
%F 年-月-日
%g 年份的后两位数字,使用基于周的年
%G 年分,使用基于周的年
%h 简写的月份名
%H 24小时制的小时
%I 12小时制的小时
%j 十进制表示的每年的第几天
%m 十进制表示的月份
%M 十时制表示的分钟数
%n 新行符
%p 本地的AM或PM的等价显示
%r 12小时的时间
%R 显示小时和分钟:hh:mm
%S 十进制的秒数
%t 水平制表符
%T 显示时分秒:hh:mm:ss
%u 每周的第几天,星期一为第一天 (值从0到6,星期一为0)
%U 第年的第几周,把星期日做为第一天(值从0到53)
%V 每年的第几周,使用基于周的年
%w 十进制表示的星期几(值从0到6,星期天为0)
%W 每年的第几周,把星期一做为第一天(值从0到53)
%x 标准的日期串
%X 标准的时间串
%y 不带世纪的十进制年份(值从0到99)
%Y 带世纪部分的十制年份
%z,%Z 时区名称,如果不能得到时区名称则返回空字符。
%% 百分号

转自:http://www.jb51.net/article/47957.htm

10月 272014
 

非常好的一篇文章,学习了:http://jackyin5918.iteye.com/blog/1918076

Spring Aop Advise方法(增强方法) 中获取目标方法的参数

 

1. 概念 

   

   切面类: 一种特殊bean,通过aop配置,其中的方法(增强方法),会对目标bean的目标方法做一些增强处理

   (比如在目标方法之前或之后调用等).

   

   切入点(pointcut): 一种规则,普通bean中符合这种规则的方法,将成为上面切面类中所说的目标方法,接受切面类方法

   的特殊处理.

   

   增强方法(Advice),包括aop:befor,aop:after,aop:after-retuing,aop:around,aop:throwing等.

   

2. 配置片段:

     

Xml代码  收藏代码

  1. <!– AOP测试的chinese –>  
  2.             <bean id=“chinese_aop” class=“test.aop.Chinese” />  
  3.             <!– 定义一个普通bean,作为切面bean –>  
  4.             <bean id=“accessArgAspect” class=“test.aop.aspect.AccessArgAspect” />  
  5.             <!– AOP配置  –>   
  6.             <aop:config>  
  7.               <!– 配置切面aspect –>  
  8.               <aop:aspect id=“aspect” ref=“accessArgAspect”>  
  9.                 <aop:after-returning   
  10.                   pointcut=“execution(* test.aop.*.*(..))”   
  11.                   method=“access”  
  12.                   returning=“retval”  
  13.                   arg-names=“time,food,retval”   
  14.                 />  
  15.               </aop:aspect>   
  16.             </aop:config>  
Xml代码  收藏代码

  1. <!– AOP测试的chinese –>  
  2.             <bean id=“chinese_aop” class=“test.aop.Chinese” />  
  3.             <!– 定义一个普通bean,作为切面bean –>  
  4.             <bean id=“accessArgAspect” class=“test.aop.aspect.AccessArgAspect” />  
  5.             <!– AOP配置  –>   
  6.             <aop:config>  
  7.               <!– 配置切面aspect –>  
  8.               <aop:aspect id=“aspect” ref=“accessArgAspect”>  
  9.                 <aop:after-returning   
  10.                   pointcut=“execution(* test.aop.*.*(..))”   
  11.                   method=“access”  
  12.                   returning=“retval”  
  13.                   arg-names=“time,food,retval”   
  14.                 />  
  15.               </aop:aspect>   
  16.             </aop:config>  

       

    上面的配置中:

    <bean id=”chinese_aop” class=”test.aop.Chinese” />

    配置了普通的bean,该bean中的一些方法

    即将满足切入点配置规则,接受切面类中增强方法(Advice)的增强处理.

    

    <bean id=”accessArgAspect” class=”test.aop.aspect.AccessArgAspect” /> 定义一个切面类,

    切面类可以是一个普通的bean.

    

    <aop:config>

      <!–配置切面aspect,通过ref关联到前面配置的作为切面类的bean–>

      <aop:aspect id=”aspect” ref=”accessArgAspect”>

        <!– 配置一种aop:after-returning增强处理–>

        <aop:after-returning

          <!– 切入点 规则,符合这个规则的普通bean中的方法将接受增强处理 –>

          pointcut=”execution(*test.aop.*.*(..)) and args(food,time,..)”  

          <!– 切面类中,作为增强处理的方法的名称 –>

          method=”access”

          <!– 普通bean,接受增强处理方法的返回值,void的类型被视为null –> 

          returning=”retval” 

          <!– 切面类中增强方法的参数名,这个配置可以省略 –>

          arg-names=”time,food,retval”

        />

        

      </aop:aspect>

    </aop:config>

    

3. 参数绑定

   切面类 方法(增强方法)获取 目标方法(普通bean中接受增强方法处理的方法) 参数的方式称为参数绑定.

   

   (1) 增强方法 不需要传递参数,则不需要参数绑定.

   

   (2) 增强方法中,只有一个JoinPoint类型的参数,使用这种参数,也不需要参数绑定.

       因为, JoinPoint类有一些方法可以获取目标方法的调用信息(包括参数信息),比如:

       Object[] getArgs(),返回在执行目标方法时传递的参数

       Signature getSignature(),获取 目标方法的签名

       Object getTarget():返回被植入 增强处理的目标对象

       Object getThis(): 返回AOP框架为目标对象生成的代理对象(Spring AOP通过动态代理实现)

       

       假如是aop:around类型的增强处理方法,可以使用ProceedingJoinPoint作为参数,

       ProceedingJoinPoint除了有上述的几个方法外,还有一个proceed()方法,替代目标方法执行.

       

   (3) 增强方法中,有普通类型的参数,

       比如public void access(Date time,String food, String retval)

       这种增强方法,必须要在pointcut中通过配置args 和 returning,保证参数正确绑定.

       (returning只针对aop:after-returning类型的增强处理,其他的可以省略)

       (即,增强方法中出现的参数名必须在pointcut配置中都得到明确的配置,否则报异常)

       pointcut=”execution(*test.aop.*.*(..)) and args(food,time,..)”

       中args(food,time,..)中的food和time是参数名,来自切面类的增强方法,不能乱写,

       必须和切面类中增强方法的参数名称一致,在切面类的增强方法参数列表中必须能找到.

       因为在增强方法public void access(Date time,String food, String retval)中,time是Date类型的,

       food是String类型的,所以pointcut(切入点)定义中and args(food,time,..)符合and前面的规则的同时

       还要符合args(food,time,..)的规则.

       args(food,time,..)表是所有 第一个参数是String类型,第二个参数是Date类型的方法才能称为目标方法.

       .. 表示可以有第三个,第四个, … , 第n个参数,但是至少有两个参数(String,Date)

       所以需要注意的有:

       a. 切面类中的增强方法参数,必须要在pointcut中有明确指定,比如

          public void access(Date time,String food, String retval)

          这个方法中三个参数food,和time通过args指定了,retval表示aop:after-returning定义的目标函数的返回值.

       b. 明确指定了参数后,AOP框架在运行时能正确绑定参数,因为:

          and args(food,time,..)表示 只对一类目标方法的调用做增强处理,这种目标方法是:在准备调用这种目标方法时,

          实际传递给它的参数为food和time所表示的类型(food和time必须在增强方法的参数列表中找到,这样就根据增强方法确定了food和time的类型).

          并且,传递参数的顺序也要是和args(food,time,..)中一致.这样在调用目标方法时,至少会按顺序传递food,time两个参数,

          AOP框架可以将这两个参数传递给 增强方法.

   

   (4) 增强方法中 有 JoinPoint和普通类型参数,

       则必须将JoinPoint类型的参数作为第一个参数,普通参数从第二个开始.

       其他的处理方式,按照上面(3)中仅含有普通参数的方式处理.

       

 主要代码;

Java代码  收藏代码

  1. package test.aop;  
  2.   
  3. import java.util.Date;  
  4.   
  5. /** 
  6.  *  
  7.  * 普通bean的接口 
  8.  * 
  9.  */  
  10. public interface Person  
  11. {  
  12.   String sayHello(String name);  
  13.   void eat(String food, Date time);  
  14.   void eat2(String food, Date time,String test);  
  15. }  
Java代码  收藏代码

  1. package test.aop;  
  2.   
  3. import java.util.Date;  
  4.   
  5. /** 
  6.  *  
  7.  * 普通bean的接口 
  8.  * 
  9.  */  
  10. public interface Person  
  11. {  
  12.   String sayHello(String name);  
  13.   void eat(String food, Date time);  
  14.   void eat2(String food, Date time,String test);  
  15. }  

 

Java代码  收藏代码

  1. package test.aop;  
  2.   
  3. import java.util.Date;  
  4.   
  5. /** 
  6.  *  
  7.  *一个普通bean,eat方法和sayHello方法,是需要被切入,动态影响的 
  8.  * 
  9.  */  
  10. public class Chinese implements Person  
  11. {  
  12.   
  13.   @Override  
  14.   public void eat(String afood, Date atime)  
  15.   {  
  16.     System.out.println(“正在吃: “ + afood + “, 时间是: “ + atime);  
  17.   }  
  18.   
  19.   @Override  
  20.   public String sayHello(String name)  
  21.   {  
  22.     return name + ” Hello, Spring AOP.”;  
  23.   }  
  24.     
  25.   public void eat2(String afood, Date atime,String test)  
  26.   {  
  27.     System.out.println(“eat2 ——— 正在吃: “ + afood + “, 时间是: “ + atime + “, eat2里面的test= “ + test);  
  28.   }  
  29.   
  30. }  
Java代码  收藏代码

  1. package test.aop;  
  2.   
  3. import java.util.Date;  
  4.   
  5. /** 
  6.  *  
  7.  *一个普通bean,eat方法和sayHello方法,是需要被切入,动态影响的 
  8.  * 
  9.  */  
  10. public class Chinese implements Person  
  11. {  
  12.   
  13.   @Override  
  14.   public void eat(String afood, Date atime)  
  15.   {  
  16.     System.out.println(“正在吃: “ + afood + “, 时间是: “ + atime);  
  17.   }  
  18.   
  19.   @Override  
  20.   public String sayHello(String name)  
  21.   {  
  22.     return name + ” Hello, Spring AOP.”;  
  23.   }  
  24.     
  25.   public void eat2(String afood, Date atime,String test)  
  26.   {  
  27.     System.out.println(“eat2 ——— 正在吃: “ + afood + “, 时间是: “ + atime + “, eat2里面的test= “ + test);  
  28.   }  
  29.   
  30. }  

 

Java代码  收藏代码

  1. package test.aop.aspect;  
  2.   
  3. import java.util.Arrays;  
  4. import java.util.Date;  
  5.   
  6. import org.aspectj.lang.JoinPoint;  
  7.   
  8. /** 
  9.  *  
  10.  * 定义切面类,处理test.aop.Chinese.eat() 
  11.  * 
  12.  */  
  13. public class AccessArgAspect  
  14. {  
  15.     
  16.   //普通的 增强方法  
  17.   public void access(Date time,String food, String retval)  
  18.   {  
  19.     System.out.println(“”);  
  20.       
  21.     System.out.println(“目标方法中 String 参数为: “ + food);  
  22.     System.out.println(“目标方法中 String 参数为: “ + time);  
  23.     System.out.println(“目标方法 返回值: “ + retval);  
  24.       
  25.     System.out.println(“模拟记录日志…”);  
  26.       
  27.   }  
  28.     
  29.   /** 
  30.    * 第一个参数为JoinPoint类型的增强方法,JoinPoint必须为第一个参数 
  31.    * @param jp 
  32.    * @param time 
  33.    * @param food 
  34.    * @param retval 
  35.    */  
  36.   public void accessWithJoinPoint(JoinPoint jp,Date time,String food)  
  37.   {  
  38.     System.out.println(“”);  
  39.     System.out.println(“JoinPoint.getArgs()获取参数列表:” + Arrays.toString(jp.getArgs()));  
  40.       
  41.     System.out.println(“JoinPoint jp —- 目标方法中 String 参数为: “ + food);  
  42.     System.out.println(“JoinPoint jp —- 目标方法中 String 参数为: “ + time);  
  43.       
  44.     System.out.println(“JoinPoint jp —- 模拟记录日志…”);  
  45.       
  46.   }  
  47. }  
Java代码  收藏代码

  1. package test.aop.aspect;  
  2.   
  3. import java.util.Arrays;  
  4. import java.util.Date;  
  5.   
  6. import org.aspectj.lang.JoinPoint;  
  7.   
  8. /** 
  9.  *  
  10.  * 定义切面类,处理test.aop.Chinese.eat() 
  11.  * 
  12.  */  
  13. public class AccessArgAspect  
  14. {  
  15.     
  16.   //普通的 增强方法  
  17.   public void access(Date time,String food, String retval)  
  18.   {  
  19.     System.out.println(“”);  
  20.       
  21.     System.out.println(“目标方法中 String 参数为: “ + food);  
  22.     System.out.println(“目标方法中 String 参数为: “ + time);  
  23.     System.out.println(“目标方法 返回值: “ + retval);  
  24.       
  25.     System.out.println(“模拟记录日志…”);  
  26.       
  27.   }  
  28.     
  29.   /** 
  30.    * 第一个参数为JoinPoint类型的增强方法,JoinPoint必须为第一个参数 
  31.    * @param jp 
  32.    * @param time 
  33.    * @param food 
  34.    * @param retval 
  35.    */  
  36.   public void accessWithJoinPoint(JoinPoint jp,Date time,String food)  
  37.   {  
  38.     System.out.println(“”);  
  39.     System.out.println(“JoinPoint.getArgs()获取参数列表:” + Arrays.toString(jp.getArgs()));  
  40.       
  41.     System.out.println(“JoinPoint jp —- 目标方法中 String 参数为: “ + food);  
  42.     System.out.println(“JoinPoint jp —- 目标方法中 String 参数为: “ + time);  
  43.       
  44.     System.out.println(“JoinPoint jp —- 模拟记录日志…”);  
  45.       
  46.   }  
  47. }  

 

Java代码  收藏代码

  1. package test.aop;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import org.springframework.context.ApplicationContext;  
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  7.   
  8. /** 
  9.  *  
  10.  * AOP客户端测试类 
  11.  * 
  12.  */  
  13. public class TestClient  
  14. {  
  15.   public static void main(String[] args)  
  16.   {  
  17.     ApplicationContext ctx = new ClassPathXmlApplicationContext(“bean.xml”);  
  18.     System.out.println(ctx);  
  19.       
  20.     Person person = ctx.getBean(“chinese_aop”,Person.class);  
  21.       
  22.     person.sayHello(“jack”);  
  23.       
  24.     person.eat(“米饭”,new Date());  
  25.       
  26.     person.eat2(“米饭”,new Date(),“test”);  
  27.   }  
  28. }  
Java代码  收藏代码

  1. package test.aop;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import org.springframework.context.ApplicationContext;  
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  7.   
  8. /** 
  9.  *  
  10.  * AOP客户端测试类 
  11.  * 
  12.  */  
  13. public class TestClient  
  14. {  
  15.   public static void main(String[] args)  
  16.   {  
  17.     ApplicationContext ctx = new ClassPathXmlApplicationContext(“bean.xml”);  
  18.     System.out.println(ctx);  
  19.       
  20.     Person person = ctx.getBean(“chinese_aop”,Person.class);  
  21.       
  22.     person.sayHello(“jack”);  
  23.       
  24.     person.eat(“米饭”,new Date());  
  25.       
  26.     person.eat2(“米饭”,new Date(),“test”);  
  27.   }  
  28. }  

 

Xml代码  收藏代码

  1. <?xml version=“1.0” encoding=“UTF-8”?>    
  2. <beans xmlns=“http://www.springframework.org/schema/beans”    
  3.         xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”    
  4.         xmlns:aop=“http://www.springframework.org/schema/aop”  
  5.         xsi:schemaLocation=”http://www.springframework.org/schema/beans    
  6.             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.             http://www.springframework.org/schema/aop   
  8.             http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
  9.             http://www.springframework.org/schema/tx   
  10.             http://www.springframework.org/schema/tx/spring-tx-3.0.xsd”>   
  11.               
  12.             <!– 小试牛刀 property使用 name,value–>  
  13.             <bean id=“personService” class=“test.spring.PersonService”>  
  14.               <property name=“name” value=“wawa”></property>  
  15.             </bean>  
  16.               
  17.             <!–   
  18.                   设值注入  
  19.                 property使用 name,ref ,  
  20.                 ref也是一个bean的id,ref 可以在stoneAxe和steelAxe之间随意切换,而不用修改java代码   
  21.             —>  
  22.             <bean id=“chinese” class=“test.ioc.setter.Chinese”>  
  23.               <property name=“axe” ref=“steelAxe”></property>  
  24.             </bean>  
  25.             <bean id=“stoneAxe” class=“test.ioc.setter.StoneAxe” />   
  26.             <bean id=“steelAxe” class=“test.ioc.setter.SteelAxe” />   
  27.               
  28.             <!–   
  29.                 构造注入  
  30.                 constructor-arg标签,ref ,  
  31.                 ref也是一个bean的id,ref 可以在stoneAxe和steelAxe之间随意切换,而不用修改java代码  
  32.                 constructor-arg 也可以配置value,表示传递给构造函数的是一个 普通的值,而不是另一个bean   
  33.             —>  
  34.             <bean id=“chinese1” class=“test.ioc.constructor.Chinese”>  
  35.               <constructor-arg ref=“steelAxe” />   
  36.             </bean>  
  37.               
  38.             <!– 国际化 –>  
  39.            <bean id=“messageSource” class=“org.springframework.context.support.ResourceBundleMessageSource”>  
  40.               <property name=“basenames” >  
  41.                 <list>  
  42.                   <!– 这里的value可带路径   –>  
  43.                   <value>message</value>  
  44.                 </list>  
  45.               </property>   
  46.             </bean>  
  47.               
  48.             <!–   
  49.               ApplicationContext的事件机制   
  50.                 在Spring中配置了实现ApplicationListener接口的Bean,  
  51.               Spring容器就会把这个Bean当成容器事件的监听器  
  52.             —>  
  53.             <bean class=“test.springevent.EmainNotifier” />   
  54.               
  55.             <!– bean中获取 ApplicationContext引用–>  
  56.             <bean name=“beangetappcontext” class=“test.bean.get.appcontext.BeanGetAppContext” />  
  57.               
  58.             <!– AOP测试的chinese –>  
  59.             <bean id=“chinese_aop” class=“test.aop.Chinese” />  
  60.             <!– 定义一个普通bean,作为切面bean –>  
  61.             <bean id=“accessArgAspect” class=“test.aop.aspect.AccessArgAspect” />  
  62.             <!– AOP配置  –>   
  63.             <aop:config>  
  64.               <!– 配置切面aspect –>  
  65.               <aop:aspect id=“aspect” ref=“accessArgAspect”>  
  66.                 <aop:after-returning   
  67.                   pointcut=“execution(* test.aop.*.*(..)) and args(food,time,..)”   
  68.                   method=“access”  
  69.                   returning=“retval”  
  70.                   arg-names=“time,food,retval”   
  71.                 />  
  72.                   
  73.                 <aop:before   
  74.                   pointcut=“execution(* test.aop.*.*(..)) and args(food,time,..)”   
  75.                   method=“accessWithJoinPoint”  
  76.                 />  
  77.                   
  78.               </aop:aspect>   
  79.             </aop:config>  
  80.                
  81. </beans>   
Xml代码  收藏代码

  1. <?xml version=“1.0” encoding=“UTF-8”?>    
  2. <beans xmlns=“http://www.springframework.org/schema/beans”    
  3.         xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance”    
  4.         xmlns:aop=“http://www.springframework.org/schema/aop”  
  5.         xsi:schemaLocation=”http://www.springframework.org/schema/beans    
  6.             http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
  7.             http://www.springframework.org/schema/aop   
  8.             http://www.springframework.org/schema/aop/spring-aop-3.0.xsd  
  9.             http://www.springframework.org/schema/tx   
  10.             http://www.springframework.org/schema/tx/spring-tx-3.0.xsd”>   
  11.               
  12.             <!– 小试牛刀 property使用 name,value–>  
  13.             <bean id=“personService” class=“test.spring.PersonService”>  
  14.               <property name=“name” value=“wawa”></property>  
  15.             </bean>  
  16.               
  17.             <!–   
  18.                   设值注入  
  19.                 property使用 name,ref ,  
  20.                 ref也是一个bean的id,ref 可以在stoneAxe和steelAxe之间随意切换,而不用修改java代码   
  21.             —>  
  22.             <bean id=“chinese” class=“test.ioc.setter.Chinese”>  
  23.               <property name=“axe” ref=“steelAxe”></property>  
  24.             </bean>  
  25.             <bean id=“stoneAxe” class=“test.ioc.setter.StoneAxe” />   
  26.             <bean id=“steelAxe” class=“test.ioc.setter.SteelAxe” />   
  27.               
  28.             <!–   
  29.                 构造注入  
  30.                 constructor-arg标签,ref ,  
  31.                 ref也是一个bean的id,ref 可以在stoneAxe和steelAxe之间随意切换,而不用修改java代码  
  32.                 constructor-arg 也可以配置value,表示传递给构造函数的是一个 普通的值,而不是另一个bean   
  33.             —>  
  34.             <bean id=“chinese1” class=“test.ioc.constructor.Chinese”>  
  35.               <constructor-arg ref=“steelAxe” />   
  36.             </bean>  
  37.               
  38.             <!– 国际化 –>  
  39.            <bean id=“messageSource” class=“org.springframework.context.support.ResourceBundleMessageSource”>  
  40.               <property name=“basenames” >  
  41.                 <list>  
  42.                   <!– 这里的value可带路径   –>  
  43.                   <value>message</value>  
  44.                 </list>  
  45.               </property>   
  46.             </bean>  
  47.               
  48.             <!–   
  49.               ApplicationContext的事件机制   
  50.                 在Spring中配置了实现ApplicationListener接口的Bean,  
  51.               Spring容器就会把这个Bean当成容器事件的监听器  
  52.             —>  
  53.             <bean class=“test.springevent.EmainNotifier” />   
  54.               
  55.             <!– bean中获取 ApplicationContext引用–>  
  56.             <bean name=“beangetappcontext” class=“test.bean.get.appcontext.BeanGetAppContext” />  
  57.               
  58.             <!– AOP测试的chinese –>  
  59.             <bean id=“chinese_aop” class=“test.aop.Chinese” />  
  60.             <!– 定义一个普通bean,作为切面bean –>  
  61.             <bean id=“accessArgAspect” class=“test.aop.aspect.AccessArgAspect” />  
  62.             <!– AOP配置  –>   
  63.             <aop:config>  
  64.               <!– 配置切面aspect –>  
  65.               <aop:aspect id=“aspect” ref=“accessArgAspect”>  
  66.                 <aop:after-returning   
  67.                   pointcut=“execution(* test.aop.*.*(..)) and args(food,time,..)”   
  68.                   method=“access”  
  69.                   returning=“retval”  
  70.                   arg-names=“time,food,retval”   
  71.                 />  
  72.                   
  73.                 <aop:before   
  74.                   pointcut=“execution(* test.aop.*.*(..)) and args(food,time,..)”   
  75.                   method=“accessWithJoinPoint”  
  76.                 />  
  77.                   
  78.               </aop:aspect>   
  79.             </aop:config>  
  80.                
  81. </beans>   

 

工程文件注:

 

使用Spring 3.2.0的所有ja包,

3.2.0的srping包,做AOP需要依赖(Spring 3.2.0中去除了依赖包,需要自己找)

com.springsource.org.aopalliance-1.0.0.jar,下载地址http://ebr.springsource.com/repository/app/bundle/version/detail?name=org.springframework.aop&version=3.2.0.RELEASE

还有,3.0.2的com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar包,

下载3.0.2版本的依赖包以后,找

spring-framework-3.0.2.RELEASE-dependencies (1)org.aspectjcom.springsource.org.aspectj.weaver1.6.8.RELEASE这个目录里面有