SpringStruts2Hibernate整合

男娘i 2022-05-12 04:56 227阅读 0赞

SSH框架：  
(1)action层:控制层(表示层) : struts2 SpringMVC   
是一个控制器,管理业务调度和管理跳转的,从这可以跳转到Service层,调用Service中的方法,可以对前端请求进行业务逻辑处理

(2)service层: 业务层 Spring:  
负责所有层之间的关系处理(通过依赖注入),松耦合降低耦合度. Spring AOP  
管理具体的功能(做相应的业务逻辑处理),Action只是负责管理,Servcie负责实施.

(3) Dao层:数据库访问层(持久层) Hibernate Mybatis  
主要做数据库的交互工作,数据访问层,用来访问数据实现数据库的持久化(把内存中的数据永久的保存到硬盘中).  
这里连接数据库操作的是Hibernate,完成增删改查  
Hibernate最大的好处是根据数据库中的表,反向生成实体类,并且还有关系在里面,还有它对数据的操作也很方便.  
(4)entity层(数据实体层) Hibernate

Spring的出现,减少了各类中的调用关系,将这些关系都转化到配置文件中
    ApplicationContext.xml:控制struts和后台逻辑之间的关系
             Struts:控制界面和Action之间的关系 --> 
    ContextLoaderListener 监听器(web.xml里面的)-->
             Spring-->
       LocalSessionFactoryBean(sessionFactory.xml,配置hibernate session工厂类似于   cfg配置)--> 
             hibernate

SSH中各个框架的作用

/*
     * struts2: 整个应用架构的骨架,负责应用中MVC模块的实现,向下层传递前端请求,向上层传递服务响应,主要作用于action层
     * Spring: 主要作用于依赖注入(DI)和控制反转(IOC)以达到解耦的目的,用于对整个与应用中的bean实例进行管理,作用SSH各个层
     * Hibernate: 主要用于数据库操作,提供更加便捷的数据库操作框架,主要作用于Dao层
     */

SSH整合步骤  
1.Struts2框架的web项目搭建起来  
2.将Spring框架整合到web项目中,在web.xml中通过监听器记载Spring的配置文件.

<context-param>
    		<param-name>contextConfigLocation</param-name>
    		<param-value>classpath:ApplicationContext.xml</param-value>
    	</context-param>
    	<listener>
    	
    		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    	</listener>
    
    	<filter>
    		<filter-name>struts2</filter-name>
    		<filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>
    	</filter>
    	<filter-mapping>
    		<filter-name>struts2</filter-name>
    		<url-pattern>/*</url-pattern>   
    	</filter-mapping>

3.将action相关的对象配置到Spring中,action的对象时多例模式,需要将scope设置为原型模式.  
在struts.xml中使用action时,将class配置为spring中的id名称

<bean id="employeeAction" class="com.xalo.action.EmployeeAction" scope="prototype">
            <property name="employeeService" ref="employeeService"></property>
         </bean>

<struts>
    
    	
    	<constant name="struts.action.extension" value="action,,"></constant>
    	
    	<constant name="struts.devMode" value="true"></constant>
    	
    	<constant name="struts.configuration.xml.reload" value="true"></constant>
    	
    	<constant name="struts.freemarker.beanwrapperCache" value="flase"></constant>
    	
    
    
    <package name = "User" extends="json-default" namespace="/employee">
        <action name = "queryUser" class="employeeAction" method="queryUser">
         
           <result name="success" type="json">
               <param name="root">result</param>
           </result>
         </action>
    </package>
    
    </struts>

4.在Spring中配置数据源(DataSource)

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
             
           <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
            
            <property name="jdbcUrl" value="jdbc:mysql://127.0.0.1:3306/MHMS?useUnicode=true&characterEncoding=utf8&useSSL=false"/>
            
            <property name="user" value="root"/>
            
            <property name="password" value="12345678"/>
            
            <property name="maxPoolSize" value="10"></property>
            <property name="minPoolSize" value="3"></property>
             <property name="maxIdleTime" value="600"></property>
             <property name="initialPoolSize" value="3"></property>
             <property name="acquireIncrement" value="5" />
             <property name="checkoutTimeout" value="300000"></property>
             <property name="idleConnectionTestPeriod" value="800"></property>
             <property name="acquireRetryAttempts" value="30" /> 
             <property name="maxStatements" value="0" />
             <property name="breakAfterAcquireFailure" value="false" />
         </bean>

5.Hibernate的sessionFactory对象交给Spring进行管理,配置sessionFactory(LocalSessionFactoryBean)  
6.配置Spring的事务

<bean id="sessionFactory"
    		class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    		<property name="dataSource" ref="dataSource" />
    		
    		<property name="hibernateProperties">
    			<props>
    				
    				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
    				
    				<prop key="hibernate.hbm2ddl.auto">update</prop>
    				
    				
    				<prop key="hibernate.show_sql">true</prop>
    				
    				<prop key="hibernate.format_sql">true</prop>
    			</props>
    		</property>
    		
    		
    		 <property name="packagesToScan" value="com.xalo.model." />
    	</bean>
        
    	
    	<bean id="transactionManager"
    		class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    		<property name="sessionFactory" ref="sessionFactory"></property>
    	</bean>
    	
    	<tx:advice transaction-manager="transactionManager" id="tx">
    		<tx:attributes>		
    			<tx:method name="*" read-only="false" />
    		</tx:attributes>
    	</tx:advice>	
    	
    	   
    	<aop:config proxy-target-class="false">
    	 
    		<aop:pointcut expression="execution(* com.xalo.daoImpl.*.*(..))" id="mypointcut" />
    		
    		<aop:advisor advice-ref="tx" pointcut-ref="mypointcut" />
    	</aop:config>
    	
    	<aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>
    
    </beans>

7.将Sevice对象, dao对象在Spring中进行配置,进行依赖注入.  
将Service对象注入到action中  
将dao对象注入到service中

8.将所有的配置文件在ApplicationContext.xml中导入

<context:component-scan base-package="com.xalo.*"/>
    	
    	
    	<import resource="classpath:dateSource.xml" />
    	
    	<import resource="classpath:sessionFactory.xml" />
    	
        <import resource="classpath:beans_employee.xml"/>

SSH框架继承的两个类和一个接口  
Serializable接口

/*
     *Serializable:序列化
     *    hibernate有二级缓存,缓存会将对象写进硬盘,就必须序列化,只有序列化的对象
     * 才可以存储在储存设备上,以及兼容对象在网络中的传输等
     */
    public class User implements Serializable {     
        }

HibernateDaoSupport类

/*
      *   对hibernate的增删改查操作的封装,通过依赖注入将sessionFactory注入给当前对象
      *通过getHibernateTemplate()进行增删改查
      */
    public class BaseDaoImpl extends HibernateDaoSupport implements BaseDaoInter {
     /*
      *   在对数据库进行增删改查中,需要使用try...catch,
      *因为有时会莫名失败,解决报错信息返回用户界面问题.
      *get():只能根据id查询,并且查询出来的只是一条记录
      *load(): 采用延迟加载,getHibernateTemplate().load(User.class, user)
      *find(): 查询出来的是一个集合
      */
      //清理缓存,常常用于,先删除,后增加,再查询的情况
        getHibernateTemplate().clear();
      //刷新缓存,把内存中的sql文及时给执行
       getHibernateTemplate().flush();
    }

ActionSupport类

/*ActionSupport:
     *  ActionSupport类是一个工具类,它已经实现了Action接口.除此之外,它还实现了Validateable接口
     * 提供了数据效验功能.通过继承该ActionSupport类,可以简化Struts2的Action开发
     * 在validatable接口中定义了一个validate()方法,重写该方法,它会在execute()方法之前执行
     * 如果效验失败,会转入input处,必须在配置该Action时配置input属性.
     * 如果效验单输入域出现错误,则将错误添加到ActionSupport类的fieldErrors域中,然后通过OGNL表达式负责输出.
     * ActionSupport还提供了一个getTex(string key)方法还实现了国际化,该方法从资源文件上获取国际化信息
     * struts2通常直接使用Action封装HTTP请求参数,因此Action类里还应该包含与请求参数对应的属为属性提供setter和getter方法
     */
     Action接口有:
     public static final java.lang.String SUCCESS = "success";
       public static final java.lang.String NONE = "none";
       public static final java.lang.String ERROR = "error";
       public static final java.lang.String INPUT = "input";
       public static final java.lang.String LOGIN = "login";
       public abstract java.lang.String execute() throws java.lang.Exception;
       
    public class UserAction extends ActionSupport {
     
      }

Struts2访问Servlet的三种方式:  
在Struts2中,Action并没有直接和Servlet API耦合,在实现业务逻辑时,经常要访问Servlet中的对象,  
如: request session appllication等  
在Struts2中,访问Servlet API有三种方法: 分别是实现特定接口,通过ServletActionContext类, 通过ActionContext类

/*
     *通过ServletConfig对对象传递
     *在action中使用servletAPI
     *第一种方式: 
     * 通过实现struts2提供的接口使用,不推荐使用,和ServletAPI耦合度过高,action类对servlet包的依赖度过高
     * 当servlet中的包进行修改时或者更新,对应的action中也需要进行更新,维护action成本高
     * 接口: ServletRequestAware ServletResponseAware SessionAware  ApplicationAware ServletContextAware
     * 第二种方式:  继承自 ActionSupport
     * struts2将servlet相关的API都封装在了 ServletActionContext中,通过该对象直接获取
     * 第三种方式:
     *  通过action的上下文(actionContext)获取
     */
     //第二种方式
     public class SecondServletAction extends ActionSupport {
        @Override
        public String execute() throws Exception {
           HttpServletRequest request = ServletActionContext.getRequest();
           HttpSession session =  request.getSession();
            User user = (User) request.getAttribute("user");
                 ServletActionContext.getResponse();
        	    ServletActionContext.getServletContext();
             return NONE;
            }
        }
    //第三种方式
     public class ThridServletAction extends ActionSupport{
         @Override
        public String execute() throws Exception {
          ActionContext context = ActionContext.getContext(); //获取action的上下文对象,本质上就是map
          context.put("name","张小凡");//等同于request.setAttribute(key, value);
          HttpParameters  parameters = context.getParameters(); //获取request中的参数列表
          //获取前端提交的name信息
          //如果前端提交的数据中有多个参数的键一样,我们根据这个键获取的结果就是一个数组
          Parameter parameters = parameters.get("name");
          String[] ps = parameter.getMultipleValues();
            for (String string : ps) {
    			  System.out.println(string);
    		}
          //如果url里面只有一个name,就用getValue()方法
           System.out.println(parameter.getValue()); 
           
           //获取servlet 中的对象
      HttpServletRequest request = (HttpServletRequest) context.get(StrutsStatics.HTTP_REQUEST);   
       context.get(StrutsStatics.HTTP_RESPONSE);
       context.get(StrutsStatics.PAGE_CONTEXT);
       context.get(StrutsStatics.SERVLET_CONTEXT);  //转发或者调用include方法用
       context.get(StrutsStatics.SERVLET_DISPATCHER);
           return NONE;
          } 
         }

ActionContext.getContext.getSession()方法

/*
     *JSP/Servlet有个原生的session对象,这是九大内置对象中的一个,类型是HttpSession session
     *函数方法是setAttrribute(), getAttribute().
     *struts2中对底层的web容器对象做了二次封装,封装为Map的类型用于封装全局变量
     *在struts2中获取和获取对象通过: ActionContext.getContext.getSession()方法获得
     * Map<Strring,Object> map对象
     */

Struts2 Result 返回JSON对象详解

https://blog.csdn.net/qq_29663071/article/details/53103021

SSH中的注解  
Hibernate注解

@Entity
    @Table(name="classRoom")
    @Id  //映射生成主键
    @GeneratedValue(strategy = GenerationType.IDENTITY) //定义主键生成策略,自动递增
    @Column(name = "cid")
    private Integer cid;
    @Basic(fetch = FetchType.EAGER, optional = true) //声明属性的存取策略,立即获取
    @Column(name = "name")
    private String name;
    
    //关联映射
    //(1)一对多(教室---学生)
    //mappedBy = "多端的关联属性名"表明当前类放弃关联关系的维护,交由对方的关联数属性维护    targetEntity:写对方的实体类型
    @OneToMany(mappedBy = "classRoom", targetEntity = Student.class)
    private Set<Student> students = new HashSet<>();
    
    @ManyToOne(targetEntity = ClassRoom.class, cascade = CascadeType.ALL)
      //@JoinColum(name="对方的数据库外键名称")
    @joinColumn(name = "id")
     private ClassRoom classRoom;
    
    //(2)多对多(教师---学科)
    //teachers: 当前类Course放弃了维护权,由对方的关联属性courses来维护
    @ManyToMany(mappedBy = "teachers", targetEntity = Course.class)
    private Set<Course> courses = new HashSet<>();
    
    //当前类teacher独立拥有了维护权,所以其关联关系上设置cascade属性,否则无法维护关联关系
    @ManyToMany(cascade = CascadeType.ALL)
    private Set<Teacher> teachers = new HashSet<>();
    
    //(3)一对一(man---woman)
    @OneToOne(mappedBy = "man", targetEntity = Woman.class)
    private Woman woman;
    
    @OneToOne(targetEntity = Man.class, cascade = CascadeType.ALL)
    @JoinColumn(name = "id")   //指定外键的名称
    private Man man;

Hibernate.cfg.xml配置

<hibernate-configuration>
    	
    	<session-factory>	
    	   
    	  
    	  <property name="hibernate.connection.url">jdbc:mysql://127.0.0.1:3306/hibernatem?characterEncoding=utf8</property>
    	   
    	  <property name="hibernate.connection.username">root</property>
    	    
    	  <property name="hibernate.connection.password">12345678</property>
    	   
    	  <property name="hibernate.connection.driver_class">com.mysql.cj.jdbc.Driver</property>  
    	   
    	  <property name="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>
    	  
    	  
    	  <property name="show_sql">true</property>
    	  
    	  <property name="format_sql">true</property>
    	  
    	    
    	  <property name="hbm2ddl.auto">create</property>
    	  
    	  
           <mapping class="com.xalo.model.ClassRoom"/> 
    	   <mapping class="com.xalo.model.Student"/>   
                
             <mapping class="com.xalo.model.Man"/>
             <mapping class="com.xalo.model.Woman"/> 
             
             <mapping class="com.xalo.model.Teacher"/>
             <mapping class="com.xalo.model.Course"/>        
      </session-factory>
    </hibernate-configuration>

Struts2常用注解  
Struts.xml  
用了注解就不需要配置Struts.xml文件了.

@Controller("userAction")
    /*如果我们只是给前端返回json数据,并不进行界面的跳转,package就继承自json-default.
        要使用json-default包需要导入struts2的json插件(struts2-json-plugin-jar)*/
    @ParentPackage("json-default")
    @Namespace("/user") 
    @Action(value = "queryUser", results = { @Result(name = "success", type = "json", params = { "root", "result" }) })

Spring常用注解  
Spring的一个核心功能是IOC,就是将Bean初始化加载到容器中.  
Bean加载到容器的方法: Spring注解方式和SpringXML方式

//下面这四个注解实质上属于同一类注解,用法相同,功能相同,区别在于表示组件的类型.
    @Component可以代替@Repository、@Service、@Controller，因为这三个注解是被@Component标注的。
    
    @Component: // 标准一个普通的spring Bean类
    @Repository: //标注一个dao组件类
    @Service: //标注一个业务逻辑组件类
    @Controller: //标注一个控制器组件类,表明当前类是一个处理器
        将当前实体交给spring管理,等同于在IOC配置了<bean id="FirstController" class="包名.类名">
        value指定Bean的id名称,如果不指定默认为类名,如果Controller中只配置value,可以省略value直接写值
    
    @Scope("prototype")  // action是多例模式,需要将scope设置为原型模式
    
    //在Spring的IOC容器中指定一个dao层的bean,如果value不指定默认该对象的类名,如果指定,id为value的值
    @Repository(value = "userDao")
    
    //接收前端传递过来的json数据, 当返回值不是逻辑视图名称,而是一组数据, 相当于response中的writer方法 response.getWriter().writer("方法返回值")
    @ResponseBody 
    
     /*依赖注入
      *@Autowired(required = false):默认是按照type注入,如果想按照id注入,就要配合@Qualifier来使用
      *        required:如果找不到bean注入 true(默认)   异常:false: 不注入即可,不会报异常
      *@Qualifier:配合上面的注解使用, byName
      *@Resourse: 按照id注入 javaEE提供的依赖注入的注解1.6之后才可以使用
      */
     @Autowired 
     @Qualifier("userDao") 
     @Resourse

@Repository(value = "userDao")
    public class UserDaoImpl extends BaseDaoImpl implements UserDaoInter {
      
       @Resourse(name = "sessionFactory")
       public void setMySessionFactory(SessionFactory sessionFactory){
           super.setSessionFactory(sessionFactory);
        }
        
        //根据id查询某个用户信息
     /*
      *get()方法根据id查询出来的只是一条记录.
      *load()方法采用延迟加载:getHibernateTemplate().load(PurchaserOrder.class,purOrderId);
      * find()
      */
        @Override
    	public User uqueryUser(Integer uId) {
    		try {			
    			User user  =  getHibernateTemplate().get(User.class, uId);
    			System.out.println(user);
    			return user;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		     return nul
       }
       
     @Service("userService") 
    public class UserSeviceImpl implements UserServiceInter {
        @Autowired
    	@Qualifier("userDao")
       //将dao层对象注入service层
        private UserDaoInter userDao;
        private HashMap<String, Object> map = new HashMap<>();
        
        public void setUserDao(UserDaoInter userDao) {
    		this.userDao = userDao;
    	}
    
    	public HashMap<String, Object> getMap() {
    		return map;
    	}
    
    	public void setMap(HashMap<String, Object> map) {
    		this.map = map;
    	}
    	// 根据id查询用户
    	@Override
    	public Map<String, Object> uqueryUser(Integer uId) {
    		User user = userDao.uqueryUser(uId);
    		if (user == null) {
    			map.put("code", CodeInter.FAILED);
    			map.put("msg", "没有查询到用户信息");
    		} else {
    			map.put("code", CodeInter.SUCCESS);
    			map.put("msg", "查询成功");
    			map.put("queryUser", user);
    		}
    		return map;
    	}
    	
    @Controller("userAction")
    @Scope("prototype") 
    @ParentPackage("json-default") 								
    @Namespace("/user")
     public class UserAction extends ActionSupport {
        @Autowired
    	@Qualifier("userService")
    	// 将service依赖注入action层
    	private UserServiceInter userService;
    	
    	//接收前端传递过来的参数
    	 private User user;
    	 
    	  public void setUserService(UserServiceInter userService) {
    		this.userService = userService;
    	}
     //接收前端传递过来的json数据
      @ResponseBody
    	public User getUser() {
    		return user;
    	}
    
    	public void setUser(User user) {
    		this.user = user;
    	}
    	
    @Action(value = "queryUser", results = { @Result(name = "success", type = "json", params = { "root", "result" }) })
    	// 根据uId查询用户信息
    	public String uqueryUser() {		
    		result = userService.uqueryUser(user.getuId());
    		System.out.println(result);
    //Action层里面方法的返回值return " ",后面写的是视图名称,  SUCCESS:里面封装的是"success"
    		return SUCCESS;
    	}
         }

向前端返回值的方式:  
一般情况下,给前端返回集合就行,就不需要进行json解析了.  
在SSH整合时,返回字符串会莫名奇妙的报错.  
Json解析:  
前后台传输的信息其实都是字符串,解析是把字符串重新变成json类型的对象,这样就能对里面的各种类型的属性或对象做操作了.  
(1)返回集合

//(1)ManagerAction.java
    public class ManagerAction extends ActionSupport {
        private User user; //接收前端传递过来的参数
        private HashMap<String, Object> result; //给前端返回结果
        private ManagerServiceInter managerService; //setter依赖注入ManagerServiceImpl对象
        
        public void setManagerService(ManagerServiceInter managerService) {
    		this.managerService = managerService;
    	}
    	//给传过来的参数跟返回的结果提供setter和getter方法
    	//根据id查询某个用户信息
    	public String uqueryUser() {
    		result = managerService.uqueryUser(user.getuId());
    		System.out.println(result);
    		return SUCCESS;
    	}
       }
       
    //(2)ManagerServiceImpl.java
       private ManagerDaoInter managerDao; //setter依赖注入ManagerDaoImpl的对象   
       private HashMap<String, Object> map = new HashMap<>(); 
       
      public void setManagerDao(ManagerDaoInter managerDao) {
    		this.managerDao = managerDao;
    	}
       
    public class ManagerServiceImpl implements ManagerServiceInter {
     // 根据id查询某个用户信息
    	@Override
    	public HashMap<String, Object> uqueryUser(Integer uId) {
    		User user = managerDao.uqueryUser(uId);
    		if (user == null) {
    			map.put("code", CodeInter.FAILED);
    			map.put("msg", "查询失败");
    		} else {
    			map.put("code", CodeInter.SUCCESS);
    			map.put("msg", "查询成功");
    			map.put("queryUser", user);
    		}
    		return map;
    	}
    	}
    
    //(3)ManagerDaoImpl.java
      //BaseDaoImpl里面封装着公共的方法,继承自HibernateDaoSupport
    public class ManagerDaoImpl extends BaseDaoImpl implements ManagerDaoInter{
        // 根据id查询某个用户信息
    	@Override
    	public User uqueryUser(Integer uId) {
    		try {			
    			User user = getHibernateTemplate().get(User.class, uId);
    			System.out.println(user);
    			return user;
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return null;
    	}
       }

(2)返回字符串

private JSONObject json = new JSONObject();
               if (user != null) {
    				    json.put("code", ErrorCode.SUCCESS);
    				    json.put("msg", "登录成功");
     	           } else {
     			      json.put("code", ErrorCode.LOGINERROR);
    				      json.put("msg", "登录失败");			        }
    	           }
    		               return json.toString();

添加一个输入框

<label>用户id</label>
    
    <input id="IDQuery" type="uId" disabled="disabled" style=" border:black solid; width: 150px"/>
    <button id="selects">查询</button>
     
     
     $("#selects").click(function(){
        var uId = $("#IDQuery").val(); 
        $.ajax({
           type: "post",
           url: "user/queryUser.action",
           data: "user.uId=" + uId, 
          success:function(respdate){ 
               var code = respdata["code"];
               var msg = respdata["msg"];
               var users = respdata["queryUser"]; 
               console.log(users);       
           },
        });
     });

JavaScript:

<%@ page language="java" contentType="text/html; charset=UTF-8"
    	pageEncoding="UTF-8"%>
    	
    
    <%@ taglib prefix="s" uri="/struts-tags"%>
    
      
     <%@taglib prefix="spring" uri="http://www.springframework.org/tags" %>
    
    
    <link rel = “stylesheet” type = “text/css” href = “”/>
    
    
    <script type="text/javascript" src = "js/文件名"></script>
    
    
    <button id="selects" onclick = " ">点击按钮</button>
    
    
    
    
    
    $(document).ready(function(){
          });
          
     $(function(){
        });   
    
     $().ready(function(){
          });
          
    
    $("#selects").click(function(){
          });
          
    
     window.onload = function(){
          //执行代码
        }
       
     
         
         $(document).ready(function(){
              $("#selects").click(function(){
                  $("p").hide();
              });
                 });
         
          $(document).ready(function(){
             $("#selects").click(function{
                 $("#test").hide();
              });
             });
        
         $(document).ready(function(){
              $("#selects").click((){
                 $(".test").hide();
               });
              });
        
    
     
           
     <div class="kv-item ue-clear">
      <label><span class="impInfo">*</span>性      别</label>
    	<div class="kv-item-content">
    		  <span class="choose">
                  <span class="checkboxouter">
                    <input type="radio" name="sex" value="男" />
                    <span class="radio"></span>
    		      </span>
    	               <span class="text">男</span>
    		  </span>
    		  
    		 <span class="choose">
                <span class="checkboxouter">
                    <input type="radio" name="sex"  value="女" />
                    <span class="radio"></span>
    	        </span>
    			      <span class="text">女</span>
    	     </span>
    	</div>
    	
    	<span class="choose">
    	   <span class="checkboxouter">
              <input type="radio" name="sex" value="保密" checked/>
              <span class="radio"></span>
    	   </span>
    	        <span class="text">保密</span>
       </span>
    </div>
    
       var sex = $("input[name = 'sex']:checked").val();
    
    
       alert(code + ":" + msg);
             
     
        location.reload();
     
     
     
       
       var jsondata = JSON.parse(jsondata);
    
    
       console.log("jsondata" + JSON.stringify(jsondata)); 
    
    var msg = jsondata["msg"];
      
    $(".msg").test(msg);
    console.log("msg:" + msg);

JQuery判断radio(单选框)是否选中和获取选中值方法总结

https://www.jb51.net/article/64141.htm

前端页面知识点: 十分全面

http://www.runoob.com

javaScript刷新页面location.reload()用法:

http://www.jquerycn.cn/a_11620
    //在js编程中多使用location.reload实现页面刷新
    //这两句在某些情况下可以代替location.reload()而不会出现重试对话框达到刷新效果
    window.location.href=""; 
    window.location.reload;

国际化:  
loginAndRegisterForManager.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    	pageEncoding="UTF-8"%>
    
    <%@ taglib prefix="s" uri="/struts-tags"%>
    <h2><s:test namer="loginTitle"></s:test></h2>
    <div>
      <div class="msg" style="color: red">
      <s:text name="loginName"></s:text> 
      <input id="mAccount" type="text" placeholder='<s:text name="loginName"></s:text>'><br>
      <s:text name="loginPassword"></s:text> 
      <input id="mPassword" type="password"   placeholder='<s:text name="loginPassword"></s:text>'><br>
      <input id="submit" type="button" value='<s:text name="loginTitle"></s:text>' style="margin-top:10px; width: 120px; height: 30px; background-color: red; font-size: 15px; border-radius: 5px; margin-left: 155px"/>			   
    </div>
    
      <a href="aa.action?request_locale=zh_CN"><s:text name="chinese"></s:text></a>  
      <a href="aa.action?request_locale=en_US"><s:text name="english"></s:text></a>

struts\_loginAndRegister.xml

beans\_loginAndRegister.xml

xalo\_en\_US.properties

loginTitle=login
    loginName=name
    loginPassWord=passWord
    chinese=chinese

xalo\_zh\_CN.properties

loginTitle=\u767B\u5F55
    loginName=\u767B\u5F55\u7528\u6237\u540D
    loginPassword=\u767B\u5F55\u5BC6\u7801
    chinese=\u4E2D\u6587

CCAction

public class CCAction extends ActionSupport {
    
    	@Override
    	public String execute() throws Exception {
    
    		return SUCCESS;
    	}
    }