java：Spring框架1（基本配置，简单基础代码实现）

1.基本配置：

　　

　　

　　

　　步骤一:新建项目并添加spring依赖的jar文件和commons-logging.xx.jar:

　　步骤二:编写实体类,DAO及其实现类，Service及其实现类;

　　步骤三:在src下新建配置文件applicationContext.xml，并配置bean节点和property:

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

    <bean id="userinfoJdbcDao" class="cn.zzsxt.dao.impl.UserinfoJdbcDaoImpl"></bean>
    <bean id="userinfoHibDao" class="cn.zzsxt.dao.impl.UserinfoHibDaoImpl"></bean>
    <bean id="userinfoService" class="cn.zzsxt.service.impl.UserinfoServiceImpl">
        <property name="userinfoDao" ref="userinfoHibDao"></property>
    </bean>
</beans>

　　

　　bean节点:

　　　　id属性:用户自定义的bean的名称，使用ApplicationContext中getBean()根据此id的值从spring容器中获取已创建好的对象。

　　　　class属性:全限定的类名，spring容器会根据此类名动态创建对象

　　property节点:

　　　　name属性:必须与bean中待注入的属性名称一致，回调其对应的setter方法为该属性赋值。

　　　　ref属性:必须与待注入的对象的id一致，从spring容器中根据ref获取待注入的对象，然后回调setter方法将该对象赋值给属性。

　　

　　

　　步骤四:测试:

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserinfoService userinfoService = applicationContext.getBean(UserinfoService.class,"userinfoService");
        Userinfo user = new Userinfo();
        user.setUserId(1);
        user.setUserName("test");
        user.setUserPass("test");
        userinfoService.save(user);
    }
}

2.简单基础代码模拟实现：

　　

　　application.xml:

　　

<?xml version="1.0" encoding="UTF-8"?>
<beans>
    <!-- UserinfoJdbcDaoImpl userinfoJdbcDao = new  UserinfoJdbcDaoImpl()-->
    <bean id="userinfoJdbcDao" class="cn.zzsxt.dao.impl.UserinfoJdbcDaoImpl"></bean>
    <!--UserinfoHibDaoImpl  userinfoHibDao = new  UserinfoHibDaoImpl()-->
    <bean id="userinfoHibDao" class="cn.zzsxt.dao.impl.UserinfoHibDaoImpl"></bean>
    <!--UserinfoServiceImpl userinfoService = new UserinfoServiceImpl()  -->
    <bean id="userinfoService" class="cn.zzsxt.service.impl.UserinfoServiceImpl">
        <!--userinfoService.setUserinfoDao(userinfoJdbcDao);  -->
        <property name="userinfoDao"  ref="userinfoJdbcDao"></property>
    </bean>
</beans>

　　

　　UserinfoHibDaoImpl:

package cn.zzsxt.dao.impl;

import cn.zzsxt.dao.UserinfoDao;
import cn.zzsxt.entity.Userinfo;

public class UserinfoHibDaoImpl implements UserinfoDao {

    @Override
    public void save(Userinfo user) {
        System.out.println("利用hibernate执行了新增,新增用户"+user);
    }

}

　　UserinfoJdbcDaoImpl:

package cn.zzsxt.dao.impl;

import cn.zzsxt.dao.UserinfoDao;
import cn.zzsxt.entity.Userinfo;

public class UserinfoJdbcDaoImpl implements UserinfoDao {

    @Override
    public void save(Userinfo user) {
        System.out.println("利用jdbc执行了新增,新增用户"+user);
    }

}

　　BeanDefination:

package cn.zzsxt.framework;

import java.util.HashMap;
import java.util.Map;

/**
 * 封装配置文件applicationContext.xml中bean节点的信息
 *     <bean id="userinfoService" class="cn.zzsxt.service.impl.UserinfoServiceImpl">
 *        <property name="userinfoDao"  ref="userinfoHibDao"></property>
 *    </bean>
 * @author Think
 *
 */
public class BeanDefination {
    private String beanId;//封装id属性的值
    private String beanClass;//封装class属性的值
    //封装该bean节点的所有property子节点的信息,利用property的name做键，利用property的信息做值
    private Map<String,PropertyDefination> propsMap = new HashMap<String,PropertyDefination>();

    public String getBeanId() {
        return beanId;
    }
    public void setBeanId(String beanId) {
        this.beanId = beanId;
    }
    public String getBeanClass() {
        return beanClass;
    }
    public void setBeanClass(String beanClass) {
        this.beanClass = beanClass;
    }
    public Map<String, PropertyDefination> getPropsMap() {
        return propsMap;
    }
    public void setPropsMap(Map<String, PropertyDefination> propsMap) {
        this.propsMap = propsMap;
    }
    @Override
    public String toString() {
        return "BeanDefination [beanId=" + beanId + ", beanClass=" + beanClass + ", propsMap=" + propsMap + "]";
    }

}

　　PropertyDefination:

package cn.zzsxt.framework;
/**
 * 封装applicationContext.xml中property节点的信息
 * <property name="userinfoDao"  ref="userinfoHibDao"></property>
 * @author Think
 *
 */
public class PropertyDefination {
    private String propertyName;//封装name属性的值
    private String propertyRef;//封装ref属性的值
    public String getPropertyName() {
        return propertyName;
    }
    public void setPropertyName(String propertyName) {
        this.propertyName = propertyName;
    }
    public String getPropertyRef() {
        return propertyRef;
    }
    public void setPropertyRef(String propertyRef) {
        this.propertyRef = propertyRef;
    }
    @Override
    public String toString() {
        return "PropertyDefination [propertyName=" + propertyName + ", propertyRef=" + propertyRef + "]";
    }

}

　　UserinfoServiceImpl:

package cn.zzsxt.service.impl;

import cn.zzsxt.dao.UserinfoDao;
import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.service.UserinfoService;

public class UserinfoServiceImpl implements UserinfoService {
    private UserinfoDao userinfoDao;

    public void setUserinfoDao(UserinfoDao userinfoDao) {
        this.userinfoDao = userinfoDao;
    }

    @Override
    public void save(Userinfo user) {
        userinfoDao.save(user);
    }

}

　　SxtApplicationContext:

package cn.zzsxt.framework;

import java.io.InputStream;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.service.UserinfoService;

public class SxtApplicationContext {
    //封装所有bean节点的信息，利用bean的id做键，利用bean节点的信息做值
    private Map<String,BeanDefination> beanDefinationsMap = new HashMap<String,BeanDefination>();
    //封装所有动态创建的对象信息，利用bean的id做键，利用创建的对象做值
    private Map<String,Object>  beansMap = new HashMap<String,Object>();

    public SxtApplicationContext(){
        parseXML();//解析配置文件
        createObject();//动态创建对象
        injectObject();//为属性注入值:回调该属性的setter方法
    }
    /**
     * 解析applicationContext.xml配置文件信息。
     * 将bean节点封装成BeanDefination对象
     * 将property节点封装成PropertyDefination对象
     *
     */
    public void parseXML(){
        InputStream ips = this.getClass().getResourceAsStream("/applicationContext.xml");
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(ips);
            //获取根节点
            Element beans = document.getRootElement();//获取根节点-->beans节点
            Iterator<Element> beanIter = beans.elementIterator();
            while(beanIter.hasNext()){
                Element bean = beanIter.next();//获取bean节点
                String beanId = bean.attributeValue("id");//获取bean节点的id属性值
                String beanClass = bean.attributeValue("class");//获取bean节点的class属性值
                //将bean节点的信息封装成BeanDefination对象
                BeanDefination beanDefination = new BeanDefination();
                beanDefination.setBeanId(beanId);
                beanDefination.setBeanClass(beanClass);
                Iterator<Element> propertyIter = bean.elementIterator();
                while(propertyIter.hasNext()){
                    Element property = propertyIter.next();//获取property节点
                    String propertyName =  property.attributeValue("name");//获取property节点的name属性值
                    String propertyRef =  property.attributeValue("ref");//获取property节点的ref属性值
                    //将property节点的信息封装成PropertyDefination对象
                    PropertyDefination propertyDefination = new PropertyDefination();
                    propertyDefination.setPropertyName(propertyName);
                    propertyDefination.setPropertyRef(propertyRef);
                    //将property节点的信息添加到beanDefination的map中
                    beanDefination.getPropsMap().put(propertyName, propertyDefination);
                }
                //将beanDefination添加到beanDefinationsMap中
                beanDefinationsMap.put(beanId, beanDefination);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据配置文件中bean节点的class属性信息动态创建对象,并将创建的对象添加到beansMap中
     */
    public void createObject(){
        try {
            //1.遍历beanDefinationsMap(封装了所有bean节点的信息)
            for (Entry<String,BeanDefination> beanEntry :beanDefinationsMap.entrySet()) {
                String beanId = beanEntry.getKey();//bean的id属性的值
                BeanDefination beanDefination = beanEntry.getValue();//获取bean节点的信息
                String beanClass = beanDefination.getBeanClass();//bean的class属性的值
                Object object = Class.forName(beanClass).newInstance();//根据bean节点的class属性值(全限定的类名)动态创建对象
                //将创建的对象添加到beansMap中，利用beanId做键，利用对象做值
                beansMap.put(beanId, object);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据property节点所配置的属性信息，从容器中查找待注入的对象，回调setter方法为属性赋值。
     */
    public void injectObject(){
        try {
            for (Entry<String,BeanDefination> beanEntry :beanDefinationsMap.entrySet()) {
                String beanId = beanEntry.getKey();//bean的id属性的值
                //根据beanId从beansMap中创建的对象
                Object target=getBean(beanId);

                BeanDefination beanDefination = beanEntry.getValue();//获取bean节点的信息
                String beanClass = beanDefination.getBeanClass();//bean的class属性的值
                Class clazz = Class.forName(beanClass);//动态加载bean
                Map<String,PropertyDefination> propsMap = beanDefination.getPropsMap();//获取property节点的信息
                for (Entry<String,PropertyDefination> propertyEntry : propsMap.entrySet()) {
                    PropertyDefination propertyDefination = propertyEntry.getValue();//获取property节点的信息
                    String propertyName = propertyDefination.getPropertyName();//获取property的name属性值
                    String propertyRef = propertyDefination.getPropertyRef();//获取property的ref属性值

                    Object params = getBean(propertyRef);//根据property中的ref属性值从beansMap获取待注入的对象(要求ref属性的值必须与待注入的bean的id值一致)

                    String setterMethodName = makeSetter(propertyName);//根据property节点的name属性值，获取其对应的setter方法名

                    Method[] ms = clazz.getDeclaredMethods();
                    for (Method method : ms) {
                        String methodName = method.getName();
                        if(methodName.equals(setterMethodName)){
                            //回调setter方法
                            method.invoke(target, params);

                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 根据beanId从beansMap容器中获取创建的对象
     * @param beanId
     * @return
     */
    public Object getBean(String beanId){
        return beansMap.get(beanId);
    }
    /**
     * 根据属性名称生成对应的setter方法名: set+属性的首字母大写+其余字母
     * @param fieldName
     * @return
     */
    public String makeSetter(String fieldName){
        return "set"+fieldName.substring(0,1).toUpperCase()+fieldName.substring(1);
    }

    public static void main(String[] args) {
        SxtApplicationContext applicationContext = new SxtApplicationContext();
        UserinfoService userinfoService = (UserinfoService)applicationContext.getBean("userinfoService");
        Userinfo user = new Userinfo();
        user.setUserId(1);
        user.setUserName("admin");
        user.setUserPass("admin");
        userinfoService.save(user);
    }
}

3.spring注入（DI）：

　　application.xml:

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

    <bean id="userinfoJdbcDao" class="cn.zzsxt.dao.impl.UserinfoJdbcDaoImpl"></bean>
    <bean id="userinfoHibDao" class="cn.zzsxt.dao.impl.UserinfoHibDaoImpl"></bean>
    <bean id="userinfoService" class="cn.zzsxt.service.impl.UserinfoServiceImpl">
        <property name="userinfoDao" ref="userinfoHibDao"></property>
    </bean>
</beans>

　　beans.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--
        DI:依赖注入
        1.setter注入:回调属性的setter方法为该属性赋值
            a.为属性注入常量值:使用property的value属性
            b.为属性注入对象:使用property的ref属性
        2.构造方法注入(构造子注入):回调构造方法为属性赋值
     -->
    <bean id="user" class="cn.zzsxt.entity.Userinfo">
        <property name="userId" value="1"></property>
        <property name="userName" value="zhangsan"></property>
        <property name="userPass" value="123"></property>
    </bean>
    <!--
        构造方法注入:constructor-arg index代表的参数的下标
        a.为属性注入常量值:使用constructor-arg中的value属性
        b.为属性注入对象: 使用constructor-arg中的ref属性
     -->
    <bean id="user2" class="cn.zzsxt.entity.Userinfo2">
        <constructor-arg index="0" value="2"></constructor-arg>
        <constructor-arg index="1" value="lisi"></constructor-arg>
        <constructor-arg index="2" value="1234"></constructor-arg>
    </bean>

    <bean id="userinfoJdbcDao" class="cn.zzsxt.dao.impl.UserinfoJdbcDaoImpl"></bean>
    <bean id="userinfoService" class="cn.zzsxt.service.impl.UserinfoServiceImpl">
        <!-- 使用setter注入 -->
<!--         <property name="userinfoDao" ref="userinfoJdbcDao"></property> -->
        <!-- 使用构造函数为属性注入对象 -->
        <constructor-arg index="0" ref="userinfoJdbcDao"></constructor-arg>
    </bean>
</beans>

　　beans2.xml:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
   <!-- 为集合属性注入值:在框架的集成中较为常见 -->
   <bean id="myCollection" class="cn.zzsxt.entity.MyCollection">
           <!-- 为list类型的属性注入值 -->
           <property name="list">
               <list>
                   <value>list1</value>
                   <value>list2</value>
                   <value>list3</value>
               </list>
           </property>
           <!-- 为set类型的属性注入值 -->
           <property name="set">
               <set>
                   <value>set1</value>
                   <value>set2</value>
                   <value>set1</value>
               </set>
           </property>
           <!-- 为map类型的属性注入值 -->
           <property name="map">
               <map>
                   <entry key="key1" value="value1"></entry>
                   <entry key="key2" value="value2"></entry>
               </map>
           </property>
           <!-- 为properties类型的属性注入值 -->
           <property name="props">
               <props>
                   <prop key="p-key1">p-value1</prop>
                   <prop key="p-key2">p-value2</prop>
               </props>
           </property>
   </bean>
</beans>

　　beans3.xml:

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

      <bean id="stoneAxe" class="cn.zzsxt.ioc.StoneAxe"></bean>
      <bean id="steelAxe" class="cn.zzsxt.ioc.SteelAxe"></bean>
      <bean id="chinese" class="cn.zzsxt.ioc.Chinese">
          <property name="axe" ref="stoneAxe"></property>
      </bean>
      <bean id="american" class="cn.zzsxt.ioc.American">
          <property name="axe" ref="steelAxe"></property>
      </bean>
</beans>

　　MyCollection:

package cn.zzsxt.entity;

import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

public class MyCollection {
    private List list;
    private Set set;
    private Map map;
    private Properties props;

    public List getList() {
        return list;
    }

    public void setList(List list) {
        this.list = list;
    }

    public Set getSet() {
        return set;
    }

    public void setSet(Set set) {
        this.set = set;
    }

    public Map getMap() {
        return map;
    }

    public void setMap(Map map) {
        this.map = map;
    }

    public Properties getProps() {
        return props;
    }

    public void setProps(Properties props) {
        this.props = props;
    }

}

　　Userinfo:

package cn.zzsxt.entity;

public class Userinfo {
    private int userId;
    private String userName;
    private String userPass;

    public Userinfo(int userId, String userName, String userPass) {
        this.userId = userId;
        this.userName = userName;
        this.userPass = userPass;
    }

    public Userinfo() {
        super();
        // TODO Auto-generated constructor stub
    }

    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPass() {
        return userPass;
    }
    public void setUserPass(String userPass) {
        this.userPass = userPass;
    }
    @Override
    public String toString() {
        return "Userinfo [userId=" + userId + ", userName=" + userName + ", userPass=" + userPass + "]";
    }

}

　　UserinfoServiceImpl:

package cn.zzsxt.service.impl;

import cn.zzsxt.dao.UserinfoDao;
import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.service.UserinfoService;
/**
 * 开闭原则:
 * @author Think
 *
 */
public class UserinfoServiceImpl implements UserinfoService {
//    private UserinfoDao userinfoDao = new UserinfoHibDaoImpl();
    private UserinfoDao userinfoDao;

    public UserinfoServiceImpl() {
    }

    public UserinfoServiceImpl(UserinfoDao userinfoDao) {
        System.out.println("带参构造函数被调用了...");
        this.userinfoDao = userinfoDao;
    }

    public void setUserinfoDao(UserinfoDao userinfoDao) {
        this.userinfoDao = userinfoDao;
    }

    @Override
    public void save(Userinfo user) {
        userinfoDao.save(user);
    }

}

　　Test:

package cn.zzsxt.test;

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

import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.service.UserinfoService;

public class Test {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserinfoService userinfoService = applicationContext.getBean(UserinfoService.class,"userinfoService");
        Userinfo user = new Userinfo();
        user.setUserId(1);
        user.setUserName("test");
        user.setUserPass("test");
        userinfoService.save(user);
    }
}

　　Test2:

package cn.zzsxt.test;

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

import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.entity.Userinfo2;
import cn.zzsxt.service.UserinfoService;

public class Test2 {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
        Userinfo user = ac.getBean(Userinfo.class,"user");
        System.out.println(user);
        System.out.println("-------------");
        Userinfo2 user2 = ac.getBean(Userinfo2.class,"user2");
        System.out.println(user2);
        System.out.println("--------------------");
        UserinfoService userinfoService = ac.getBean(UserinfoService.class,"userinfoService");
        userinfoService.save(user);
    }
}

　　Test3:

package cn.zzsxt.test;

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

import cn.zzsxt.entity.MyCollection;
import cn.zzsxt.entity.Userinfo;
import cn.zzsxt.entity.Userinfo2;
import cn.zzsxt.service.UserinfoService;

public class Test3 {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans2.xml");
        MyCollection myCollection = ac.getBean(MyCollection.class,"myCollection");
        System.out.println(myCollection.getList());
        System.out.println(myCollection.getSet());
        System.out.println(myCollection.getMap());
        System.out.println(myCollection.getProps());

    }
}

　　　Axe:

package cn.zzsxt.ioc;

public interface Axe {
    public void chop();
}

　　StoneAxe:

package cn.zzsxt.ioc;

public class StoneAxe implements Axe {

    @Override
    public void chop() {
        System.out.println("我是石斧，砍人很钝!");
    }

}

　　SteelAxe:

package cn.zzsxt.ioc;

public class SteelAxe implements Axe {

    @Override
    public void chop() {
        System.out.println("我是鉄斧，砍人很锋利!");
    }

}

　　Person:

package cn.zzsxt.ioc;

public interface Person {
    public void useAxe();
}

　　Chinese:

package cn.zzsxt.ioc;

public class Chinese implements Person {
    private Axe axe;
    public void setAxe(Axe axe) {
        this.axe = axe;
    }

    @Override
    public void useAxe() {
        System.out.println("我是中国人民解放军，现在向你发出严重警告!");
        axe.chop();
    }

}

　　American:

package cn.zzsxt.ioc;

public class American implements Person {
    private Axe axe;
    public void setAxe(Axe axe) {
        this.axe = axe;
    }

    @Override
    public void useAxe() {
        System.out.println("我是美国大兵，你瞅啥!");
        axe.chop();
    }

}

　　Test:

　　

package cn.zzsxt.ioc;

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

public class Test {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("beans3.xml");
        Person p = (Person)ac.getBean("chinese");
        p.useAxe();
        System.out.println("-----------------");
        Person p2 = (Person)ac.getBean("american");
        p2.useAxe();

    }
}
时间： 2024-12-17 16:39:39

java：Spring框架1（基本配置，简单基础代码实现）的相关文章

基于Spring框架的Shiro配置

一.在web.xml中添加shiro过滤器 Xml代码   <!-- Shiro filter--> <filter> <filter-name>shiroFilter</filter-name> <filter-class> org.springframework.web.filter.DelegatingFilterProxy </filter-class> </filter> <filter-mapping&g

认识Java Spring 框架

谈起Java  开发总是离不开各种框架,当我们在使用Java初期就被各种框架的包围着,而.Net开发就比较简单了,从WinForm到Asp.Net再到APS.Net Mvc,一气呵成,开发起来那叫一个爽,但是也带来了一些问题,比如,.Net 开发者使用微软已经封装好的类库,程序员在日常的开发过程中,都不知道自己所使用的类库有多么精妙,但是Java就不一样了,它是完全开源的,可以按照自己的需求加载适合的类库,作为开发者就可以知道大牛们写的牛叉代码,也可以看到代码的重构的美妙之处.今天我们就来谈一谈

java spring框架的HelloWord

工作原因,需要了解java了.现在java开发好像基本都是spring这一套,而且初次了解的时候,实在是一头雾水. spring, spring-boot, spring-cloud, AOP,mybatis, zookeeper, Eureka, apollo, consul等等技术,涉及面太广. VS code作为编辑器可以,作为IDE用起来不太方便,我换了的eclipse学习的spring框架. 工程使用 项目使用start.spring.io中的脚手架搭建spring-boot的mave

java spring框架的定时任务

由于测试的原因,最近有接触java spring  @Scheduled的定时任务,当时还以为配置起来表达式和crontab是完全一样的,没想到还有些许不一样. 在spring中,一个cron表达式至少有6个或者7个被空格分隔的时间元素. 如下: 举例: 0 0/5 * * * ?就是每隔5分钟触发 0 15 10 * * ?   每天上午10:15触发 ps:用法: 然后再在配置文件(如application.properties文件)中设置  即可. 而在linux contab中,是5位时

Spring框架bean的配置（2）：SpEL：引用 Bean、属性和方法。。。

1.SpEL,实现 Person类,其属性如下,其get,set,tostrong方法就不写了 private String name; private Car car; private String city;//city属性是引用了Address中city的属性 private String info;//根据car的price属性来确定info,price大于30万,不大于30万 car类,其属性如下,set,get,tostring方法就不写了 private String brand;

基于java spring框架开发部标1078视频监控平台精华文章索引

部标1078视频监控平台,是一个庞杂的工程,涵盖了多层协议,部标jt808,jt809,jt1078,苏标Adas协议等,多个平台功能标准,部标796标准,部标1077标准和苏标主动安全标准,视频方面的协议有RTSP, RTMP, RTP, 音视频编码有H.264, AAC,  726,711等,消化这些协议和功能标准就已经是需要一个较长的周期了,而构建一个视频平台的架构,也是比较复杂的,后端不仅有网关,还要有流媒体服务器,转发服务器,播放器,RTSP或RTMP服务器等多个服务器模块,需要的技术

jdk源码阅读笔记之java集合框架（一）（基础篇）

结合<jdk源码>与<thinking in java>,对java集合框架做一些简要分析(本着实用主义,精简主义,遂只会挑出个人认为是高潮的部分). 先上一张java集合框架的简图: 会从以下几个方面来进行分析: java 数组; ArrayList,LinkedList与Vector; HashMap; HashSet 关于数组array: 数组的解释是:存储固定大小的同类型元素.由于是"固定大小",所以对于未知数目的元素存储就显得力不从心,遂有了集合.

基于Java spring框架的微信企业号开发中关于js-sdk的配置

在调用js-sdk的第一步,我们需要引入js-sdk的js链接,然后执行wx.config,官方示例如下所示: 1 wx.config({ 2 debug: true, // 开启调试模式,调用的所有api的返回值会在客户端alert出来,若要查看传入的参数,可以在pc端打开,参数信息会通过log打出,仅在pc端时才会打印. 3 appId: '', // 必填,企业号的唯一标识,此处填写企业号corpid 4 timestamp: , // 必填,生成签名的时间戳 5 nonceStr: ''

Spring框架第一篇之简单入门

一.下载Spring的jar包 通过http://repo.spring.io/release/org/springframework/spring/地址下载最新的Spring的zip包,当然,如果你是在使用maven工程的话,可以不用下载Zip包,可以直接在maven工程的pom.xml文件中添加Spring的依赖即可. 二.创建工程导入jar包 第一篇的内容记录一些入门知识点,所以只需要导入几个必要的基础包则可,这里项目只导入Spring的以下几个包: spring-core-4.3.9.R